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

certora_cli/CertoraProver/certoraBuild.py

@@ -20,22 +20,24 @@ import os
 import re
 import shutil
 import sys
+import tempfile
 import typing
 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
 
+from CertoraProver.castingInstrumenter import generate_casting_instrumentation
 from CertoraProver.certoraBuildCacheManager import CertoraBuildCacheManager, CachedFiles
 from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference, ContractExtension, ContractInSDC, SDC, \
     Instrumentation, InsertBefore, InsertAfter, UnspecializedSourceFinder, instrumentation_logger
 from CertoraProver.certoraCompilerParameters import SolcParameters
+from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes, VyperMetadata
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
-from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
-from Shared.certoraUtils import is_relative_to
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
@@ -54,7 +56,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 +78,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 +91,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:
         """
@@ -198,11 +203,18 @@ class PresetImmutableReference(ImmutableReference):
 # this function is Solidity specific.
 # todo: create certoraBuildUtilsSol.py file, where such solidity specific functions will be.
 def generate_finder_body(f: Func, internal_id: int, sym: int, compiler_collector: CompilerCollectorSol,
-                         compressed: bool = False) -> Optional[Tuple[List[int], str]]:
+                         compressed: bool = False,
+                         should_generate_inlining: bool = True) -> Optional[Tuple[List[int], str]]:
     if compressed:
         return generate_compressed_finder(
             f, internal_id, sym, compiler_collector
         )
+    elif not should_generate_inlining:
+        # We should not generate inlining as reported in CERT-9399, only when compressed=False.
+        # used_symbols is being generated the exact same way as in generate_full_finder
+        used_symbols = [i for i in range(len(f.fullArgs))]
+        return used_symbols, ''
+
     else:
         return generate_full_finder(
             f, internal_id, sym, compiler_collector
@@ -398,8 +410,9 @@ def get_modifier_param_type_name(ind: int, def_node: Dict[str, Any], f: Func) ->
 
 def generate_modifier_finder(f: Func, internal_id: int, sym: int,
                              compiler_collector: CompilerCollectorSol, def_node: Dict[str, Any],
-                             compress: bool) -> Optional[Tuple[str, str]]:
-    compressed = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=compress)
+                             compress: bool, should_generate_inlining: bool) -> Optional[Tuple[str, str]]:
+    compressed = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=compress,
+                                      should_generate_inlining=should_generate_inlining)
     if compressed is None:
         return None
     modifier_name = f"logInternal{internal_id}"
@@ -411,6 +424,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}"
@@ -420,9 +435,10 @@ def generate_modifier_finder(f: Func, internal_id: int, sym: int,
         return f'{modifier_name}({",".join(arg_strings)})', modifier_body
 
 
-def generate_inline_finder(f: Func, internal_id: int, sym: int,
-                           compiler_collector: CompilerCollectorSol, should_compress: bool) -> Optional[str]:
-    finder = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=should_compress)
+def generate_inline_finder(f: Func, internal_id: int, sym: int, compiler_collector: CompilerCollectorSol,
+                           should_compress: bool, should_generate_inlining: bool) -> Optional[str]:
+    finder = generate_finder_body(f, internal_id, sym, compiler_collector, compressed=should_compress,
+                                  should_generate_inlining=should_generate_inlining)
     if finder is None:
         return None
     return finder[1]
@@ -441,8 +457,12 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
             if path_obj.is_file():
                 json_dict_posix_paths[path_obj.as_posix()] = json_dict[entry][file_path]
             else:
-                fatal_error(compiler_logger, f"The path of the source file {file_path}"
-                                             f"in the standard json file {json_dict} does not exist")
+                json_dict_str = str(json_dict)
+                # protecting against long strings
+                if len(json_dict_str) > 200:
+                    json_dict_str = json_dict_str[:200] + '...'
+                fatal_error(compiler_logger, f"The path of the source file {file_path} "
+                                             f"in the standard json file does not exist!\n{json_dict_str} ")
         json_dict[entry] = json_dict_posix_paths
 
 
@@ -823,6 +843,7 @@ class CertoraBuildGenerator:
                     body_location = body_node["src"]
                 elif body_node is None and func_def["implemented"]:
                     ast_logger.debug(f"No body for {func_def} but ast claims it is implemented")
+                location: Optional[str] = func_def.get("src", None)
 
                 if original_contract is not None:
                     if method := original_contract.find_method(func_name, solidity_type_args):
@@ -847,14 +868,17 @@ class CertoraBuildGenerator:
                     func_def[STATEMUT] in ["nonpayable", "view", "pure"],
                     c_is_lib,
                     is_constructor,
+                    func_def.get("kind") == CertoraBuildGenerator.FREEFUNCTION_STRING,
                     func_def[STATEMUT],
                     func_visibility,
                     func_def["implemented"],
                     func_def.get("overrides", None) is not None,
+                    func_def.get("virtual", False),
                     contract_name,
                     source_bytes,
                     ast_id=func_def.get("id", None),
                     original_file=original_file,
+                    location=location,
                     body_location=body_location,
                 )
 
@@ -906,15 +930,18 @@ class CertoraBuildGenerator:
                         notpayable=is_not_payable,
                         fromLib=c_is_lib,
                         isConstructor=False,
+                        is_free_func=False,
                         stateMutability=state_mutability,
                         implemented=True,
                         overrides=public_state_var.get("overrides", None) is not None,
+                        virtual=False,
                         # according to Solidity docs, getter functions have external visibility
                         visibility="external",
                         contractName=contract_name,
                         source_bytes=SourceBytes.from_ast_node(public_state_var),
                         ast_id=None,
                         original_file=c_file,
+                        location=None,
                         body_location=None,
                     )
                 )
@@ -948,6 +975,8 @@ class CertoraBuildGenerator:
                             ret = solc_type == "address"
                         elif isinstance(ct_type, CT.StructType):
                             ret = solc_type == "tuple"
+                        elif isinstance(ct_type, CT.EnumType):
+                            ret = solc_type == "uint8"
                     return ret
 
                 fs = [f for f in fs if all(compareTypes(a.type, i)
@@ -968,7 +997,7 @@ class CertoraBuildGenerator:
                 assert len(f.returns) == len(fabi["outputs"]), \
                     f"function collected for {fabi['name']} has the wrong number of return values"
                 assert all(compareTypes(a.type, i) for a, i in zip(f.returns, fabi["outputs"])), \
-                    f"function collected for {fabi['name']} has the wrong types of return values"
+                    f"function collected for {fabi['name']} has the wrong types of return values. {[t.type.type_string for t in f.returns]} vs {fabi['outputs']}"
 
         verify_collected_all_abi_funcs(
             [f for f in data["abi"] if f["type"] == "function"],
@@ -1198,10 +1227,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:
@@ -1347,49 +1381,63 @@ 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_map_bool_attribute_value(self, contract_file_path: Path, attr_name: str) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, attr_name)
+        assert isinstance(match, (bool, type(None))), f"Expected {attr_name} to be bool or None, got {type(match)}"
+        return bool(match)
+
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'solc_via_ir')
+
+    def get_vyper_venom_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'vyper_venom')
+
+    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, int, type(None))), f"Expected solc_optimize to be string, integer , got {type(match)}"
+        if isinstance(match, int):
+            match = str(match)
+        return match
+
+    def _handle_venom(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_vyper_venom_value(contract_file_path):
+            settings_dict["experimentalCodegen"] = True
+
+    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"
@@ -1412,13 +1460,18 @@ class CertoraBuildGenerator:
                 compiler_version = compiler_collector.compiler_version
                 major, minor, patch = compiler_version
 
-                err_msg = "--finder_friendly_optimizer option supports solc versions 0.6.7 - 0.8.25 only, " \
-                          f"got {major}.{minor}.{patch}"
+                err_msg = \
+                    f"Unsupported solc version {major}.{minor}.{patch} for `solc_via_ir`. " \
+                    f"Supported versions: 0.6.7 – 0.8.25.\n" \
+                    f"Use `solc_via_ir_map` to disable `solc_via_ir` for specific files with older compiler versions."
+
                 yul_optimizer_steps = None
                 if major != 0:
                     raise Util.CertoraUserInputError(err_msg)
                 elif minor < 6 or (minor == 6 and patch < 7):
                     raise Util.CertoraUserInputError(err_msg)
+                elif self.context.yul_optimizer_steps:
+                    yul_optimizer_steps = self.context.yul_optimizer_steps
                 elif (minor == 6 and patch >= 7) or (minor == 7 and 0 <= patch <= 1):
                     yul_optimizer_steps = solc0_6_7_to_0_7_1
                 elif minor == 7 and 2 <= patch <= 5:
@@ -1433,8 +1486,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.'
 
@@ -1456,7 +1509,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
@@ -1467,6 +1520,9 @@ class CertoraBuildGenerator:
         self._handle_via_ir(contract_file_path, settings_dict)
         self._handle_evm_version(contract_file_path, settings_dict)
         self._handle_optimize(contract_file_path, settings_dict, compiler_collector)
+        compiler_lang = compiler_collector.smart_contract_lang
+        if compiler_lang == CompilerLangVy():
+            self._handle_venom(contract_file_path, settings_dict)
 
     @staticmethod
     def solc_setting_optimizer_runs(settings_dict: Dict[str, Any]) -> Tuple[bool, Optional[int]]:
@@ -1500,7 +1556,8 @@ class CertoraBuildGenerator:
                       contract_file_posix_abs: Path,
                       contract_file_as_provided: str,
                       remappings: List[str],
-                      compiler_collector: CompilerCollector) -> Dict[str, Any]:
+                      compiler_collector: CompilerCollector,
+                      compile_wd: Path) -> Dict[str, Any]:
         """
         when calling solc with the standard_json api, instead of passing it flags, we pass it json to request what we
         want -- currently we only use this to retrieve storage layout as this is the only way to do that,
@@ -1511,18 +1568,22 @@ class CertoraBuildGenerator:
         @param compiler_collector: Solidity or Vyper compiler collector
         @return:
         """
+        solc_json_contract_key = os.path.relpath(contract_file_as_provided, compile_wd) if self.context.use_relpaths_for_solc_json else contract_file_posix_abs
         compiler_collector_lang = compiler_collector.smart_contract_lang
         if compiler_collector_lang == CompilerLangSol() or compiler_collector_lang == CompilerLangYul():
-            sources_dict = {str(contract_file_posix_abs): {
+            sources_dict = {str(solc_json_contract_key): {
                 "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:
                 contents = f.read()
                 sources_dict = {str(contract_file_posix_abs): {"content": contents}}
                 output_selection = ["abi", "evm.bytecode", "evm.deployedBytecode", "evm.methodIdentifiers"]
+                if compiler_collector.compiler_version >= (0, 4, 4):
+                    output_selection += ["metadata", "evm.deployedBytecode.symbolMap"]
                 ast_selection = ["ast"]
 
         settings_dict: Dict[str, Any] = \
@@ -1536,7 +1597,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")
@@ -1739,6 +1800,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 +1851,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,13 +1867,10 @@ 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,
-                                            compiler_collector)
+                                            compiler_collector, compile_wd)
         standard_json_input = json.dumps(input_for_solc).encode("utf-8")
         compiler_logger.debug(f"about to run in {compile_wd} the command: {collect_cmd}")
         compiler_logger.debug(f"solc input = {json.dumps(input_for_solc, indent=4)}")
@@ -1862,7 +1926,7 @@ class CertoraBuildGenerator:
             contract_file_abs = str(Util.abs_norm_path(contract_file))
 
             # using os.path.relpath because Path.relative_to cannot go up the directory tree (no ..)
-            contract_file_rel = os.path.relpath(Path(contract_file_abs), Path.cwd())
+            contract_file_rel = os.path.relpath(Path(contract_file_abs), compile_wd)
 
             build_logger.debug(f"available keys: {data['contracts'].keys()}")
             if contract_file_rel in data[CONTRACTS]:
@@ -1961,7 +2025,15 @@ class CertoraBuildGenerator:
             srclist = {"0": file_abs_path}
             report_srclist = {"0": file_abs_path}
 
-        report_source_file = report_srclist[[idx for idx in srclist if srclist[idx] == file_abs_path][0]]
+        # Annoyingly, this is currently used just for... presentation?!
+        # We should clean up report_source_file from all places...
+
+        build_logger.debug(f"Finding report source file, abs path {file_abs_path} relative to {compile_wd}")
+        if self.context.use_relpaths_for_solc_json:
+            orig_report_source_file = Util.abs_posix_path(os.path.relpath(file_abs_path, compile_wd))
+        else:
+            orig_report_source_file = file_abs_path
+        report_source_file = report_srclist[[idx for idx in srclist if Util.abs_posix_path(srclist[idx]) == orig_report_source_file][0]]
 
         # all "contracts in SDC" are the same for every primary contract of the compiled file.
         # we can therefore compute those just once...
@@ -1992,8 +2064,9 @@ class CertoraBuildGenerator:
 
             build_logger.debug(f"finding primary contract address of {file_compiler_path}:{primary_contract} in "
                                f"{contracts_with_chosen_addresses}")
+            path_to_find = os.path.relpath(file_compiler_path, compile_wd) if self.context.use_relpaths_for_solc_json else file_compiler_path
             primary_contract_address = \
-                self.find_contract_address_str(file_compiler_path,
+                self.find_contract_address_str(path_to_find,
                                                primary_contract,
                                                contracts_with_chosen_addresses)
             build_logger.debug(f"Contracts in SDC {sdc_name}: {[contract.name for contract in contracts_in_sdc]}")
@@ -2039,7 +2112,7 @@ class CertoraBuildGenerator:
                 if new_path is None:
                     file_abs_path = Util.abs_posix_path(build_arg_contract_file)
                     # for vyper, because there are no autofinders, at least find the main file
-                    if (orig_file == file_abs_path and
+                    if (Util.abs_posix_path(orig_file) == file_abs_path and
                         ((Util.get_certora_sources_dir() / build_arg_contract_file).exists() or
                          Path(build_arg_contract_file).exists())):
                         new_srclist_map[idx] = build_arg_contract_file
@@ -2054,6 +2127,7 @@ class CertoraBuildGenerator:
                 report_srclist = srclist
         else:
             report_srclist = srclist
+        build_logger.debug(f"Report source list={report_srclist}")
         return report_srclist
 
     def get_bytecode(self,
@@ -2061,7 +2135,7 @@ class CertoraBuildGenerator:
                      contract_name: str,
                      primary_contracts: List[str],
                      contracts_with_chosen_addresses: List[Tuple[int, Any]],
-                     fail_if_no_bytecode: bool
+                     is_deployed_bytecode: bool
                      ) -> str:
         """
         Computes the linked bytecode object from the Solidity compiler output.
@@ -2072,20 +2146,31 @@ class CertoraBuildGenerator:
         @param primary_contracts - the names of the primary contracts we check to have a bytecode
         @param contracts_with_chosen_addresses - a list of tuples of addresses and the
             associated contract identifier
-        @param fail_if_no_bytecode - true if the function should fail if bytecode object is missing,
+        @param is_deployed_bytecode - true if we deal with deployed (runtime) bytecode,
+            thus the function should fail if bytecode object is missing,
             false otherwise
         @returns linked bytecode object
         """
         # TODO: Only contract_name should be necessary. This requires a lot more test cases to make sure we're not
         # missing any weird solidity outputs.
         bytecode_ = bytecode_object["object"]
-        bytecode = self.collect_and_link_bytecode(contract_name, contracts_with_chosen_addresses,
-                                                  bytecode_, bytecode_object.get("linkReferences", {}))
+        try:
+            bytecode = self.collect_and_link_bytecode(contract_name, contracts_with_chosen_addresses,
+                                                      bytecode_, bytecode_object.get("linkReferences", {}))
+        except Util.CertoraUserInputError as e:
+            if is_deployed_bytecode:
+                raise e
+            else:
+                prefix_msg = f"Failed to find a dependency library while building the "\
+                             f"constructor bytecode of {contract_name}. "\
+                             f"If you need the contract, import the missing library directly and add a dummy usage:\n"
+                orig_msg = str(e)
+                raise Util.CertoraUserInputError(prefix_msg + orig_msg)
         if contract_name in primary_contracts and len(bytecode) == 0:
             msg = f"Contract {contract_name} has no bytecode. " \
                   f"It may be caused because the contract is abstract, " \
                   f"or is missing constructor code. Please check the output of the Solidity compiler."
-            if fail_if_no_bytecode:
+            if is_deployed_bytecode:
                 raise Util.CertoraUserInputError(msg)
             else:
                 build_logger.warning(msg)
@@ -2155,6 +2240,40 @@ class CertoraBuildGenerator:
             storage_slot['descriptor'] = type_descriptor.as_dict()
         return storage_data
 
+    @staticmethod
+    def add_vyper_internal_function_data(internal_funcs: Set[Func], contract_data: Dict[str, Any]) -> None:
+        metadata = contract_data["metadata"]
+        symbol_map = contract_data["evm"]["deployedBytecode"]["symbolMap"]
+
+        for internal_func in internal_funcs:
+            # find metadata entry
+            func_name = internal_func.name
+            func_info = metadata['function_info']
+            metadata_func_info = None
+            for value in func_info.values():
+                if value.get("name") == func_name:
+                    metadata_func_info = value
+                    break
+            assert metadata_func_info is not None, f"Could not find metadata for internal function {func_name}"
+            vyper_metadata = VyperMetadata()
+            if metadata_func_info.get('frame_info'):
+                vyper_metadata.frame_size = metadata_func_info['frame_info']['frame_size']
+                vyper_metadata.frame_start = metadata_func_info['frame_info']['frame_start']
+            if metadata_func_info.get('venom_via_stack'):
+                vyper_metadata.venom_via_stack = metadata_func_info['venom_via_stack']
+            if metadata_func_info.get('venom_return_via_stack'):
+                vyper_metadata.venom_return_via_stack = metadata_func_info['venom_return_via_stack']
+            pattern_in_symbol_map = re.compile(fr"{func_name}\(.*\)_runtime$")
+            matches = [k for k in symbol_map if pattern_in_symbol_map.search(k)]
+            if len(matches) == 0:
+                build_logger.warning(f"Could not find symbol map entry for {func_name} probably was inlined")
+                continue
+            elif len(matches) > 1:
+                raise RuntimeError(f"Found multiple matches for {func_name} in symbol map: {matches}")
+            else:
+                vyper_metadata.runtime_start_pc = symbol_map[matches[0]]
+            internal_func.vyper_metadata = vyper_metadata
+
     def get_contract_in_sdc(self,
                             source_code_file: str,
                             contract_name: str,
@@ -2190,14 +2309,17 @@ class CertoraBuildGenerator:
                 notpayable=x.notpayable,
                 fromLib=x.fromLib,
                 isConstructor=x.isConstructor,
+                is_free_func=False,
                 stateMutability=x.stateMutability,
                 visibility=x.visibility,
                 implemented=x.implemented,
                 overrides=x.overrides,
+                virtual=False,
                 contractName=x.contractName,
                 ast_id=x.ast_id,
                 source_bytes=x.source_bytes,
                 original_file=x.original_file,
+                location=None,
                 body_location=x.body_location,
             ) for x in clfuncs]
         elif compiler_lang == CompilerLangYul():
@@ -2246,6 +2368,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)
@@ -2260,7 +2390,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)
@@ -2268,6 +2398,9 @@ class CertoraBuildGenerator:
         else:
             compiler_parameters = None
 
+        if compiler_lang == CompilerLangVy() and compiler_collector_for_contract_file.compiler_version >= (0, 4, 4):
+            self.add_vyper_internal_function_data(internal_funcs, contract_data)
+
         return ContractInSDC(contract_name,
                              # somehow make sure this is an absolute path which obeys the autofinder remappings
                              # (i.e. make sure this file doesn't start with autoFinder_)
@@ -2296,7 +2429,8 @@ class CertoraBuildGenerator:
                              extension_contracts=list(),
                              local_assignments={},
                              branches={},
-                             requires={}
+                             requires={},
+                             internal_starts=list(internal_function_entrypoints)
                              )
 
     @staticmethod
@@ -2389,7 +2523,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
@@ -2398,6 +2532,19 @@ class CertoraBuildGenerator:
                     # (deprecate this option later)
                     should_compress = self.context.function_finder_mode == Vf.FunctionFinderMode.DEFAULT.name
 
+                if self.context.solc_optimize and self.get_solc_via_ir_value(Path(contract_file)) and \
+                   any(param_name == "" for param_name in f.paramNames):
+                    # As reported in CERT-9399, we should not generate function finder for this edge case
+
+                    instrumentation_logger.warning(f"Failed to generate auto finder for {f.name} @ {f.where()}.")
+                    instrumentation_logger.warning(
+                        "Cannot apply summaries for internal functions with unnamed argument when compiling "
+                        "using solc_optimize and solc_via_ir"
+                    )
+                    should_generate_inlining = False
+                else:
+                    should_generate_inlining = True
+
                 if len(mods) > 0:
                     # we need to add the instrumentation in a modifer because solidity modifiers will (potentially)
                     # appear before any instrumentation we add to the literal source body, which will tank the detection
@@ -2409,8 +2556,10 @@ class CertoraBuildGenerator:
                     # where in the source such modifiers will go. In order to insert a modifier, we have to have at
                     # least one modifier already present, and then insert before the first modifier's location in the
                     # source code
-                    mod_inst = generate_modifier_finder(f, internal_id, function_symbol, sdc.compiler_collector,
-                                                        def_node, compress=should_compress)
+                    mod_inst = generate_modifier_finder(
+                        f, internal_id, function_symbol, sdc.compiler_collector, def_node,
+                        compress=should_compress, should_generate_inlining=should_generate_inlining
+                    )
                     if mod_inst is None:
                         instrumentation_logger.debug(f"Modifier generation for {f.name} @ {f.where()} failed")
                         return None
@@ -2444,8 +2593,8 @@ class CertoraBuildGenerator:
                     per_file_inst[first_mod_offset] = Instrumentation(expected=bytes(modifier_name[0:1], "utf-8"),
                                                                       to_ins=modifier_invocation, mut=InsertBefore())
                 else:
-                    finder_res = generate_inline_finder(f, internal_id, function_symbol,
-                                                        sdc.compiler_collector, should_compress)
+                    finder_res = generate_inline_finder(f, internal_id, function_symbol, sdc.compiler_collector,
+                                                        should_compress, should_generate_inlining)
                     if finder_res is None:
                         instrumentation_logger.debug(f"Generating auto finder for {f.name} @ {f.where()}"
                                                      f" failed, giving up generation")
@@ -2455,6 +2604,114 @@ class CertoraBuildGenerator:
                                                                 mut=InsertAfter())
         return function_finder_by_contract, function_finder_instrumentation
 
+    def add_internal_func_harnesses(self, contract_file: str, sdc: SDC, spec_calls: List[str]) -> Optional[Tuple[Dict[str, str], Dict[str, Dict[int, Instrumentation]]]]:
+        # contract file -> byte offset -> to insert
+        harness_function_instrumentation: Dict[str, Dict[int, Instrumentation]] = defaultdict(dict)
+        # internal function name -> harness fuction name
+        harness_function_names: Dict[str, str] = {}
+
+        if not isinstance(sdc.compiler_collector, CompilerCollectorSol):
+            raise Exception(f"Encountered a compiler collector that is not solc for file {contract_file}"
+                            " when trying to add function autofinders")
+        instrumentation_logger.debug(f"Using {sdc.compiler_collector} compiler to "
+                                     f"add external function harnesses to contract {sdc.primary_contract}")
+
+        for c in sdc.contracts:
+            for f in c.internal_funcs:
+                if f"{sdc.primary_contract}.{f.name}" not in spec_calls:
+                    continue
+
+                if f.fromLib:
+                    # Even external library functions can't be called directly from spec,
+                    # so skip harnessing internal ones.
+                    continue
+
+                if f.isConstructor:
+                    continue
+
+                if f.is_free_func:
+                    # Free functions (declared outside of any contract/library) don't have visibility modifiers
+                    continue
+
+                orig_file = f.original_file
+                if not orig_file:
+                    instrumentation_logger.debug(f"missing file location for {f.name}")
+                    continue
+
+                loc = f.location
+                if not loc:
+                    instrumentation_logger.debug(f"Found a function {f.name} in "
+                                                 f"{c.name} that doesn't have a location")
+                    continue
+
+                if f.implemented:
+                    expected_end_char = b"}"
+                else:
+                    # This is a virtual function with no implementation. Declare also a virtual harness so that when
+                    # Implementing a harness for the override we can just add the `override` keyword to the harness
+                    # function as well without needing to have any extra logic at that point.
+                    expected_end_char = b";"
+
+                if len(f.fullArgs) != len(f.paramNames):
+                    instrumentation_logger.debug(f"Do not have argument names for {f.name} in"
+                                                 f" {c.name}, giving up internal function harnessing")
+                    continue
+
+                if any(ty.location == CT.TypeLocation.STORAGE for ty in f.fullArgs + f.returns):
+                    instrumentation_logger.debug(f"Function {f.name} has input arguments with 'storage' location - cannot harness it")
+                    continue
+
+                instrumentation_path = str(Util.abs_norm_path(orig_file))
+                per_file_inst = harness_function_instrumentation[instrumentation_path]
+
+                start, size, _ = loc.split(":")
+                body_end_byte = int(start) + int(size) - 1
+
+                def get_local_type_name(ty: CT.TypeInstance) -> str:
+                    # Handles imports that use 'as'. E.g. `import {A as B} from "A.sol";`
+                    ret = ty.get_source_str()
+                    assert orig_file
+                    for node in self.asts[sdc.sdc_origin_file][orig_file].values():
+                        if node["nodeType"] != "ImportDirective":
+                            continue
+                        for alias in node["symbolAliases"]:
+                            if alias["foreign"]["name"] == ty.get_source_str() and "local" in alias:
+                                ret = alias["local"]
+                                break
+
+                    # Now add the location
+                    return ret + (f" {ty.location.value}" if ty.location != CT.TypeLocation.STACK else "")
+
+                harness_name = f"{f.name}_external_harness"
+                harness_string = f" function {harness_name}({', '.join(f'{get_local_type_name(ty)} {n}' for ty, n in zip(f.fullArgs, f.paramNames))}) external"
+
+                if f.stateMutability in ["pure", "view"]:
+                    harness_string += f" {f.stateMutability}"
+
+                if f.virtual:
+                    harness_string += " virtual"
+
+                if f.overrides:
+                    harness_string += " override"
+
+                if f.returns:
+                    harness_string += f" returns ({', '.join(get_local_type_name(r) for r in f.returns)})"
+
+                if f.implemented:
+                    harness_call = f"{f.name}({', '.join(f.paramNames)})"
+                    if f.returns:
+                        harness_string += f" {{ return {harness_call}; }}"
+                    else:
+                        harness_string += f" {{ {harness_call}; }}"
+                else:
+                    harness_string += ";"
+
+                per_file_inst[body_end_byte] = Instrumentation(expected=expected_end_char, to_ins=harness_string,
+                                                               mut=InsertAfter())
+                harness_function_names[f.name] = harness_name
+
+        return harness_function_names, harness_function_instrumentation
+
     def cleanup(self) -> None:
         for sdc_name, smart_contract_lang in self.__compiled_artifacts_to_clean:
             self.cleanup_compiler_outputs(sdc_name, smart_contract_lang)
@@ -2510,6 +2767,16 @@ class CertoraBuildGenerator:
 
     def build(self, certora_verify_generator: CertoraVerifyGenerator) -> None:
         context = self.context
+
+        spec_calls: List[str] = []
+        if context.verify and not context.disallow_internal_function_calls:
+            with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
+                try:
+                    Ctx.run_local_spec_check(False, context, ["-listCalls",  tmp_file.name], print_errors=False)
+                    spec_calls = tmp_file.read().split("\n")
+                except Exception as e:
+                    instrumentation_logger.debug(f"Failed to get calls from spec\n{e}")
+
         self.context.remappings = []
         for i, build_arg_contract_file in enumerate(sorted(self.input_config.sorted_files)):
             build_logger.debug(f"\nbuilding file {build_arg_contract_file}")
@@ -2519,7 +2786,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()
@@ -2527,7 +2793,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
@@ -2562,7 +2828,7 @@ class CertoraBuildGenerator:
                 # We start by trying to instrument _all_ finders, both autofinders and source finders
                 added_finders, all_finders_success, src_finders_gen_success, post_backup_dir = self.finders_compilation_round(
                     build_arg_contract_file, i, ignore_patterns, path_for_compiler_collector_file, pre_backup_dir,
-                    sdc_pre_finders, not context.disable_source_finders)
+                    sdc_pre_finders, not context.disable_source_finders, spec_calls)
 
                 # we could have a case where source finders failed but regular finders succeeded.
                 # e.g. if we processed the AST wrong and skipped source finders generation
@@ -2574,21 +2840,21 @@ class CertoraBuildGenerator:
                     # let's try just the function autofinders
                     added_finders, function_autofinder_success, _, post_backup_dir = self.finders_compilation_round(
                         build_arg_contract_file, i, ignore_patterns, path_for_compiler_collector_file, pre_backup_dir,
-                        sdc_pre_finders, False)
+                        sdc_pre_finders, False, spec_calls)
 
                     if not function_autofinder_success:
                         self.auto_finders_failed = True
 
                 if not self.auto_finders_failed or not self.source_finders_failed:
                     # setup source_dir. note that post_backup_dir must include the finders in this case
-                    for _, _, sdc in added_finders:
+                    for _, _, _, sdc in added_finders:
                         sdc.source_dir = str(post_backup_dir.relative_to(Util.get_certora_sources_dir()))
                         sdc.orig_source_dir = str(pre_backup_dir.relative_to(Util.get_certora_sources_dir()))
             else:
                 # no point in running autofinders in vyper right now
-                added_finders = [({}, {}, sdc_pre_finder) for sdc_pre_finder in sdc_pre_finders]
+                added_finders = [({}, {}, {}, sdc_pre_finder) for sdc_pre_finder in sdc_pre_finders]
 
-            for added_func_finders, added_source_finders, sdc in added_finders:
+            for added_func_finders, added_source_finders, added_internal_function_harnesses, sdc in added_finders:
                 for contract in sdc.contracts:
                     all_functions: List[Func] = list()
                     for k, v in added_func_finders.items():
@@ -2596,6 +2862,8 @@ class CertoraBuildGenerator:
                         contract.function_finders[k] = v
                     for source_key, source_value in added_source_finders.items():
                         contract.local_assignments[source_key] = source_value
+                    if contract.name == sdc.primary_contract:
+                        contract.internal_function_harnesses = added_internal_function_harnesses
                     all_functions.extend(contract.methods)
                     all_functions.extend(contract.internal_funcs)
                     functions_unique_by_internal_rep = list()  # type: List[Func]
@@ -2649,11 +2917,182 @@ class CertoraBuildGenerator:
 
                 self.SDCs[self.get_sdc_key(sdc.primary_contract, sdc.primary_contract_address)] = sdc
 
+        if self.context.dump_asts:
+            self.dump_asts()
         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], compiler_version: str, target_file: str) -> 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")
+            rel_path = os.path.relpath(tmp_file.name, Path.cwd())
+            if self.context.compiler_map:
+                self.context.compiler_map.update({rel_path: compiler_version}, last=False)
+            # Write the harness contract with dummy fields for each namespaced storage
+            var_to_slot = storageExtension.write_harness_contract(tmp_file, harness_name, ns_storage)
+            tmp_file.flush()
+
+            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"
+                )
+
+            # 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}
+
+            def attempt_compilation() -> NewStorageInfo:
+                """Helper function to compile and extract 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', {}))
+
+            # First attempt with original content
+            try:
+                return attempt_compilation()
+            except Exception as e:
+                if not target_file:
+                    build_logger.error(f"Error extracting storage layout for {original_file}: {str(e)}")
+                    raise
+
+                # Retry with target file import
+                build_logger.info("First attempt failed, retrying with import of target file")
+
+                # Read current content
+                tmp_file.seek(0)
+                current_content = tmp_file.read()
+
+                # Prepare modified content with target import at the beginning
+                rel_target_path = os.path.relpath(target_file, Path.cwd())
+                modified_content = f'import "{rel_target_path}";\n{current_content}'
+
+                # Write modified content
+                tmp_file.seek(0)
+                tmp_file.truncate()
+                tmp_file.write(modified_content)
+                tmp_file.flush()
+
+                try:
+                    return attempt_compilation()
+                except Exception as retry_e:
+                    build_logger.error(f"Retry also failed for {original_file}: {str(retry_e)}")
+                    raise retry_e
+            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,
+                                                         get_relevant_compiler(Path(target_file), self.context),
+                                                         target_file)
+
+        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,
+                target_file if self.context.use_relpaths_for_solc_json else 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]]:
             """
@@ -2698,8 +3137,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]]] :
@@ -2716,8 +3155,9 @@ class CertoraBuildGenerator:
 
             # let's try to find the AST now
             build_file_ast = None
+            orig_path = os.path.relpath(ext_instance.original_file, Path.cwd()) if self.context.use_relpaths_for_solc_json else ext_instance.original_file
             for (k, v) in self.asts.items():
-                if ext_instance.original_file in v:
+                if orig_path in v:
                     build_file_ast = k
                     break
             if build_file_ast is None:
@@ -2725,10 +3165,10 @@ class CertoraBuildGenerator:
 
             contract_def_node = self.get_contract_def_node_ref(
                 build_file_ast,
-                ext_instance.original_file,
+                orig_path,
                 storage_ext
             )
-            def_node = self.asts[build_file_ast][ext_instance.original_file][contract_def_node]
+            def_node = self.asts[build_file_ast][orig_path][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}")
@@ -2740,41 +3180,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"]}
-            # Keep track of slots we've added, and error if we
-            # find two extensions extending the same slot
-            added_slots: 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
-                    slot = f["slot"]
-                    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}")
-
-                    if slot in target_slots:
-                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} already mapped by {target_contract.name}")
-
-                    added_slots[slot] = 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
@@ -2803,7 +3208,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,
@@ -2812,12 +3217,13 @@ class CertoraBuildGenerator:
                                   path_for_compiler_collector_file: str,
                                   pre_backup_dir: Path,
                                   sdc_pre_finders: List[SDC],
-                                  with_source_finders: bool) -> Tuple[
-            List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], SDC]], bool, bool, Path]:
+                                  with_source_finders: bool,
+                                  spec_calls: List[str]) -> Tuple[
+            List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], Dict[str, str], SDC]], bool, bool, Path]:
         added_finders_to_sdc, finders_compilation_success, source_finders_gen_success = \
             self.instrument_auto_finders(
                 build_arg_contract_file, i, sdc_pre_finders,
-                path_for_compiler_collector_file, with_source_finders)
+                path_for_compiler_collector_file, with_source_finders, spec_calls)
         # successful or not, we backup current .certora_sources for either debuggability, or for availability
         # of sources.
         post_backup_dir = self.get_fresh_backupdir(Util.POST_AUTOFINDER_BACKUP_DIR)
@@ -2889,11 +3295,12 @@ class CertoraBuildGenerator:
     def instrument_auto_finders(self, build_arg_contract_file: str, i: int,
                                 sdc_pre_finders: List[SDC],
                                 path_for_compiler_collector_file: str,
-                                instrument_source_finders: bool) -> Tuple[
-            List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], SDC]], bool, bool]:
+                                instrument_source_finders: bool,
+                                spec_calls: List[str]) -> Tuple[
+            List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], Dict[str, str], SDC]], bool, bool]:
 
         # initialization
-        ret = []  # type: List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], SDC]]
+        ret: List[Tuple[Dict[str, InternalFunc], Dict[str, UnspecializedSourceFinder], Dict[str, str], SDC]] = []
         instrumentation_logger.debug(f"Instrumenting auto finders in {build_arg_contract_file}")
         # all of the [SDC]s inside [sdc_pre_finders] have the same list of [ContractInSDC]s
         # (generated in the [collect_from_file] function).
@@ -2902,10 +3309,19 @@ class CertoraBuildGenerator:
         if added_function_finders_tuple is None:
             instrumentation_logger.warning(
                 f"Computing function finder instrumentation failed for {build_arg_contract_file}")
-            return [({}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
+            return [({}, {}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
 
         (added_function_finders, function_instr) = added_function_finders_tuple
 
+        instr = function_instr
+
+        added_internal_function_harnesses: Dict[str, str] = {}
+        if not self.context.disallow_internal_function_calls:
+            added_internal_func_harness_tuple = self.add_internal_func_harnesses(build_arg_contract_file, sdc_pre_finder, spec_calls)
+            if added_internal_func_harness_tuple:
+                instr = CertoraBuildGenerator.merge_dicts_instrumentation(function_instr, added_internal_func_harness_tuple[1])
+                added_internal_function_harnesses = added_internal_func_harness_tuple[0]
+
         source_finders_gen_succeeded = False
         if instrument_source_finders:
             try:
@@ -2914,17 +3330,24 @@ class CertoraBuildGenerator:
                 (added_source_finders, source_instr) = added_source_finders_tuple
                 # Update instr with additional instrumentations. Recall it is a map file -> offset -> instr.
                 # Function finders take precedence
-                instr = CertoraBuildGenerator.merge_dicts_instrumentation(function_instr, source_instr)
+                instr = CertoraBuildGenerator.merge_dicts_instrumentation(instr, source_instr)
                 source_finders_gen_succeeded = True
             except:  # noqa: E722
                 instrumentation_logger.warning(
                     f"Computing source finder instrumentation failed for {build_arg_contract_file}")
-                instr = function_instr
                 added_source_finders = {}
         else:
-            instr = function_instr
             added_source_finders = {}
 
+        try:
+            casting_instrumentations, casting_types = generate_casting_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder)
+        except Exception as e:
+            instrumentation_logger.warning(
+                f"Computing casting instrumentation failed for {build_arg_contract_file}: {e}", exc_info=True)
+            casting_instrumentations, casting_types = {}, {}
+
+        instr = CertoraBuildGenerator.merge_dicts_instrumentation(instr, casting_instrumentations)
+
         abs_build_arg_contract_file = Util.abs_posix_path(build_arg_contract_file)
         if abs_build_arg_contract_file not in instr:
             instrumentation_logger.debug(
@@ -2942,7 +3365,7 @@ class CertoraBuildGenerator:
                 # instrumentation should be keyed only using absolute paths
                 instrumentation_logger.warning(f"Already generated autofinder for {new_name}, "
                                                f"cannot instrument again for {contract_file}")
-                return [({}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
+                return [({}, {}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
 
             autofinder_remappings[new_name] = contract_file
 
@@ -2971,19 +3394,26 @@ class CertoraBuildGenerator:
                                 instrumentation_logger.warning("Skipping source finder generation!")
                             else:
                                 instrumentation_logger.warning("Skipping internal function finder generation!")
-                            return [({}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
+                            return [({}, {}, {}, old_sdc) for old_sdc in sdc_pre_finders], False, False
                         to_skip = to_insert.mut.insert(to_insert.to_ins, to_insert.expected, output)
                         if to_skip != 0:
                             in_file.read(to_skip)
                         read_so_far += amt + 1 + to_skip
                     output.write(in_file.read(-1))
 
+                    library_name, funcs = casting_types.get(contract_file, ("", list()))
+                    if len(funcs) > 0:
+                        output.write(bytes(f"\nlibrary {library_name}" + "{\n", "utf8"))
+                        for f in funcs:
+                            output.write(bytes(f, "utf8"))
+                        output.write(bytes("}\n", "utf8"))
+
         new_file = self.to_autofinder_file(build_arg_contract_file)
         self.context.file_to_contract[new_file] = self.context.file_to_contract[
             build_arg_contract_file]
 
         # add generated file to map attributes
-        for map_attr in Attrs.get_attribute_class().all_map_attrs():
+        for map_attr in self.context.app.attr_class.all_map_attrs():
             map_attr_value = getattr(self.context, map_attr)
             if map_attr_value and build_arg_contract_file in map_attr_value:
                 map_attr_value[new_file] = map_attr_value[build_arg_contract_file]
@@ -3003,13 +3433,13 @@ 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,
                                              reroute_main_path=True)
             for new_sdc in new_sdcs:
-                ret.append((added_function_finders, added_source_finders, new_sdc))
+                ret.append((added_function_finders, added_source_finders, added_internal_function_harnesses, new_sdc))
 
         except Util.SolcCompilationException as e:
             print(f"Encountered an exception generating autofinder {new_file} ({e}), falling back to original "
@@ -3018,7 +3448,7 @@ class CertoraBuildGenerator:
                              f"falling back to the original file {Path(build_arg_contract_file).name}", exc_info=e)
             # clean up mutation
             self.function_finder_file_remappings = {}
-            return [({}, {}, sdc_pre_finder) for sdc_pre_finder in sdc_pre_finders], False, False
+            return [({}, {}, {}, sdc_pre_finder) for sdc_pre_finder in sdc_pre_finders], False, False
         return ret, True, source_finders_gen_succeeded
 
     def to_autofinder_file(self, contract_file: str) -> str:
@@ -3031,7 +3461,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 +3471,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:
@@ -3405,13 +3835,23 @@ 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)
         if Util.REMAPPINGS_FILE.exists():
             add_to_sources(Util.REMAPPINGS_FILE)
+        foundry_toml = Util.find_nearest_foundry_toml()
+        if foundry_toml:
+            # if we find foundry.toml we add it to source tree and, if exists, the remappings.txt file from the
+            # root directory
+            foundry_root = foundry_toml.parent
+            add_to_sources(foundry_root / Util.FOUNDRY_TOML_FILE)
+            remappings_file_in_root = foundry_root / Util.REMAPPINGS_FILE
+            if remappings_file_in_root.exists():
+                add_to_sources(remappings_file_in_root)
         if context.bytecode_jsons:
             for file in context.bytecode_jsons:
                 add_to_sources(Path(file))
@@ -3437,7 +3877,21 @@ class CertoraBuildGenerator:
         return sources
 
     def __del__(self) -> None:
-        self.cleanup()
+        try:
+            self.cleanup()
+        except ImportError:
+            # Avoiding Python interpreter shutdown exceptions which are safe to ignore
+            pass
+
+    def dump_asts(self) -> None:
+        asts_dump_file = Util.get_asts_file()
+        filtered_asts = {k: v for k, v in self.asts.items() if not str(k).startswith(f"{Util.get_build_dir()}")}
+        with asts_dump_file.open("w+") as output_file:
+            try:
+                json.dump(filtered_asts, output_file, indent=4, sort_keys=True)
+            except Exception as e:
+                ast_logger.debug(f"Couldn't dump ASTs to {asts_dump_file}", exc_info=e)
+                raise
 
 
 # make sure each source file exists and its path is in absolute format
@@ -3449,20 +3903,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)
@@ -3477,7 +3930,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:
@@ -3491,16 +3944,24 @@ 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()
 
-    #  the empty file .project_directory is written in the source tree to denote the projecct directory
+    # copy context.forge_remappings to remappings.txt in the source tree, overwriting any existing remappings.txt
+    forge_remappings = getattr(context, 'forge_remappings', None)
+    if forge_remappings:
+        remappings_file_path = Util.get_certora_sources_dir() / context.cwd_rel_in_sources / Util.REMAPPINGS_FILE
+        with remappings_file_path.open("w") as remap_file:
+            for remap in context.forge_remappings:
+                remap_file.write(remap + "\n")
+
+    #  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())
         assert Path(rust_proj_dir).is_dir(), f"build_source_tree: not a directory {rust_proj_dir}"
-        proj_dir_parent_file = (Util.get_certora_sources_dir() / cwd_rel_in_sources / proj_dir_parent_relative /
+        proj_dir_parent_file = (Util.get_certora_sources_dir() / context.cwd_rel_in_sources / proj_dir_parent_relative /
                                 Util.PROJECT_DIR_FILE)
         proj_dir_parent_file.parent.mkdir(parents=True, exist_ok=True)
         proj_dir_parent_file.touch()
@@ -3516,10 +3977,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
 
-    return cwd_rel_in_sources
-
-
-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:
     """
@@ -3545,10 +4004,17 @@ 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:
-            if is_relative_to(f, absolute_sources_dir):
+        for f in paths_set:
+            if f.is_relative_to(absolute_sources_dir):
                 rel_f = f.relative_to(absolute_sources_dir)
             else:
                 # may be an absolute path already outside .certora_sources, so we can keep it.
@@ -3583,61 +4049,84 @@ 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) \
-        -> Tuple[bool, bool, CachedFiles]:
+                                certora_verify_generator: CertoraVerifyGenerator) \
+        -> Tuple[bool, CachedFiles]:
     """
     Builds either from cache (fast path) or from scratch (slow path)
-    @returns 1st tuple element whether there was a cache hit or not
-    @returns 2nd tuple element whether the build cache is enabled and applicable
-    @returns 3rd tuple element the artifacts of the build to potentially be cached
+    @returns 1st tuple element whether the cache should be saved
+    @returns 2nd tuple element the artifacts of the build to potentially be cached
     """
-    cache_hit = False
     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
+        return 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)
-    # if no match, will rebuild from scratch
-    if cached_files is not None:
-        # write to .certora_build.json
-        shutil.copyfile(cached_files.certora_build_file, Util.get_certora_build_file())
-        # write build_output_props file
-        shutil.copyfile(cached_files.build_output_props_file, Util.get_built_output_props_file())
-        # write build_cache indicator file
-        with open(Util.get_build_cache_indicator_file(), "w+") as indicator_handle:
-            json.dump({"build_cache_hit": True}, indicator_handle)
-        # write in sources all the additional paths found
-        for p in cached_files.path_with_additional_included_files.glob("*"):
-            if p.is_dir():
-                Util.safe_copy_folder(p,
-                                      Util.get_certora_sources_dir() / p.name,
-                                      shutil.ignore_patterns())
-            else:
-                shutil.copyfile(p, Util.get_certora_sources_dir() / p.name)
-        cache_hit = True
-    else:
-        # rebuild
-        cached_files = build_from_scratch(certora_build_generator,
+        return False, cached_files
+
+    cached_files = CertoraBuildCacheManager.build_from_cache(context)
+
+    if not cached_files:
+        # No match, rebuild
+        cached_files = build_from_scratch(context, certora_build_generator,
                                           certora_verify_generator,
                                           True)
+        return True, cached_files
+
+    # Cache hit!
+
+    # write to .certora_build.json
+    # This must happen _before_ searching for new internal function calls - the typechecker needs this file.
+    shutil.copyfile(cached_files.certora_build_file, Util.get_certora_build_file())
+
+    # Check whether there are any new internal function calls in the spec file - if there are then we need to build
+    # from scratch in order to create the relevant harness function.
+    if context.verify and not context.disallow_internal_function_calls:
+        with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
+            internal_calls = []
+            try:
+                Ctx.run_local_spec_check(True, context, ["-listCalls",  tmp_file.name], print_errors=False)
+                output = tmp_file.read().strip()
+                if output:
+                    internal_calls = output.split("\n")
+            except Exception as e:
+                instrumentation_logger.debug(f"Failed to get calls from spec\n{e}")
+
+            if internal_calls:
+                build_logger.info("Found new internal calls in the spec file, need to recompile anyway")
+                # There are new internal calls in the spec, we need to rebuild in order to generate the
+                # external harness functions for them.
+                cached_files = build_from_scratch(context, certora_build_generator,
+                                                  certora_verify_generator,
+                                                  True)
+                return True, cached_files
+
+    # write build_output_props file
+    shutil.copyfile(cached_files.build_output_props_file, Util.get_built_output_props_file())
+    # write build_cache indicator file
+    with open(Util.get_build_cache_indicator_file(), "w+") as indicator_handle:
+        json.dump({"build_cache_hit": True}, indicator_handle)
+    # write in sources all the additional paths found
+    for p in cached_files.path_with_additional_included_files.glob("*"):
+        if p.is_dir():
+            Util.safe_copy_folder(p,
+                                  Util.get_certora_sources_dir() / p.name,
+                                  shutil.ignore_patterns())
+        else:
+            shutil.copyfile(p, Util.get_certora_sources_dir() / p.name)
 
-    return cache_hit, True, cached_files
+    return False, cached_files
 
 
 def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> None:
@@ -3651,7 +4140,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)
 
@@ -3661,19 +4150,17 @@ 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:
-                build_logger.warning(
-                    "Local checks of CVL specification files disabled. It is recommended to enable the checks.")
-            else:
+            if Ctx.should_run_local_speck_check(context):
                 Ctx.run_local_spec_check(False, context)
 
-        certora_build_cache_manager = CertoraBuildCacheManager()
+        should_save_cache, cached_files = build_from_cache_or_scratch(context,
+                                                                      certora_build_generator,
+                                                                      certora_verify_generator)
 
-        cache_hit, build_cache_enabled, cached_files = build_from_cache_or_scratch(context,
-                                                                                   certora_build_generator,
-                                                                                   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 Ctx.should_run_local_speck_check(context) and 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
@@ -3687,8 +4174,8 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
             build_logger.debug("build_source_tree failed", exc_info=e)
 
         # 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)
+        if should_save_cache and cached_files.may_store_in_build_cache:
+            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