certora-cli-beta-mirror 8.6.3__py3-none-any.whl → 8.8.0__py3-none-any.whl

certora_cli/CertoraProver/certoraBuild.py

@@ -36,15 +36,17 @@ from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference,
     Instrumentation, InsertBefore, InsertAfter, UnspecializedSourceFinder, instrumentation_logger
 from CertoraProver.certoraCompilerParameters import SolcParameters
 from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes, VyperMetadata
+from CertoraProver.certoraOffsetConverter import generate_offset_converters
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
+from CertoraProver.uncheckedOverflowInstrumenter import generate_overflow_instrumentation, add_instrumentation
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
 from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerCollector
 from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
 from CertoraProver.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
-from CertoraProver.Compiler.CompilerCollectorVy import CompilerLangVy
+from CertoraProver.Compiler.CompilerCollectorVy import CompilerLangVy, CompilerCollectorVy
 from CertoraProver.Compiler.CompilerCollectorFactory import CompilerCollectorFactory, \
     get_relevant_compiler, get_compiler_lang
 from CertoraProver.certoraNodeFilters import NodeFilters as Nf
@@ -444,7 +446,7 @@ def generate_inline_finder(f: Func, internal_id: int, sym: int, compiler_collect
     return finder[1]
 
 
-def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contract_lang: CompilerLang) -> None:
+def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, compiler_collector: CompilerCollector) -> None:
     """
     assuming the values kept in the entry [entry] inside [json_dict] are path names
     :param json_dict: dict to iterate on
@@ -453,7 +455,7 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
     if entry in json_dict:
         json_dict_posix_paths = {}
         for file_path in json_dict[entry]:
-            path_obj = Path(smart_contract_lang.normalize_file_compiler_path_name(file_path))
+            path_obj = Path(compiler_collector.normalize_file_compiler_path_name(file_path))
             if path_obj.is_file():
                 json_dict_posix_paths[path_obj.as_posix()] = json_dict[entry][file_path]
             else:
@@ -461,7 +463,7 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
                 # 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} "
+                fatal_error(compiler_logger, f"The path of the source file {file_path} ({path_obj})"
                                              f"in the standard json file does not exist!\n{json_dict_str} ")
         json_dict[entry] = json_dict_posix_paths
 
@@ -1152,7 +1154,12 @@ class CertoraBuildGenerator:
         if file_abs_path.suffix == VY:
             smart_contract_lang: CompilerLang = CompilerLangVy()
             sdc_name = self.file_to_sdc_name[Path(contract_file).absolute()]
-            standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang)
+            """
+            maintain backward-compatibility,
+            but in reality this equiavlence checker (equivChecker.py) should be removed
+            """
+            dummyCompilerCollectorVy = CompilerCollectorVy((0, 3, 10))
+            standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang, dummyCompilerCollectorVy)
             abi = standard_json_data[CONTRACTS][str(Path(contract_file).absolute())][contract_name]['abi']
             ast_logger.debug(f"abi is: \n{abi}")
             for f in filter(lambda x: self.is_imported_abi_entry(x), abi):
@@ -1163,11 +1170,14 @@ class CertoraBuildGenerator:
         elif file_abs_path.suffix == SOL:
             smart_contract_lang = CompilerLangSol()
             sdc_name = self.file_to_sdc_name[file_abs_path]
-            compilation_path = self.get_compilation_path(sdc_name)
-            standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang)
+            compilation_path = Path(Util.abs_posix_path(contract_file))
+            compilerCollectorSol = self.compiler_coll_factory.get_compiler_collector(compilation_path)
+            standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang, compilerCollectorSol)
             storage_data = smart_contract_lang.collect_storage_layout_info(str(file_abs_path), compilation_path,
                                                                            solc, None,
-                                                                           standard_json_data)
+                                                                           standard_json_data,
+                                                                           {},  # dummy ast, not used in solc
+                                                                           str(contract_file))
             abi = storage_data[CONTRACTS][str(file_abs_path)][contract_name]["abi"]
             ast_logger.debug(f"abi is: \n{abi}")
             for f in filter(lambda x: self.is_imported_abi_entry(x), abi):
@@ -1270,7 +1280,7 @@ class CertoraBuildGenerator:
         else:
             raise RuntimeError(f"failed to get contract bytes for {contract_name} in file {contract_file}")
 
-    def get_standard_json_data(self, sdc_name: str, smart_contract_lang: CompilerLang) -> Dict[str, Any]:
+    def get_standard_json_data(self, sdc_name: str, smart_contract_lang: CompilerLang, compiler_collector : CompilerCollector) -> Dict[str, Any]:
         json_file = smart_contract_lang.compilation_output_path(sdc_name)
         process_logger.debug(f"reading standard json data from {json_file}")
         # jira CER_927 - under windows it happens the solc generate wrong
@@ -1278,7 +1288,7 @@ class CertoraBuildGenerator:
         json_dict = Util.read_json_file(json_file)
         entries = [CONTRACTS, "sources"]
         for ent in entries:
-            convert_pathname_to_posix(json_dict, ent, smart_contract_lang)
+            convert_pathname_to_posix(json_dict, ent, compiler_collector)
         return json_dict
 
     def cleanup_compiler_outputs(self, sdc_name: str, smart_contract_lang: CompilerLang) -> None:
@@ -1570,6 +1580,9 @@ class CertoraBuildGenerator:
         """
         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
+        main_contract_for_output_selection = "*"
+        search_paths_arr = None
+        additional_asts = None
         if compiler_collector_lang == CompilerLangSol() or compiler_collector_lang == CompilerLangYul():
             sources_dict = {str(solc_json_contract_key): {
                 "urls": [str(contract_file_posix_abs)]}}  # type: Dict[str, Dict[str, Any]]
@@ -1578,28 +1591,59 @@ class CertoraBuildGenerator:
                                 "evm.bytecode.functionDebugData"]
             ast_selection = ["id", "ast"]
         elif compiler_collector_lang == CompilerLangVy():
+            main_contract_for_output_selection = "*"
+            sources_dict = {}
             with open(contract_file_posix_abs) as f:
-                contents = f.read()
-                sources_dict = {str(contract_file_posix_abs): {"content": contents}}
+                if self.context.vyper_custom_std_json_in_map and contract_file_as_provided in self.context.vyper_custom_std_json_in_map:
+                    """
+                    If we're given a custom standard_json, we'll take from it the sources and
+                    the search paths.
+                    In particular, we will separate between the interfaces (*.vyi) and regular files,
+                    so that we could get the ASTs for the regular files (as those are compilation units).
+                    This was tested ONLY on a single contract
+                    (ask Shelly)
+                    and may require refinement
+                    if we get more projects.
+                    """
+                    vyper_custom_std_json_in = self.context.vyper_custom_std_json_in_map[contract_file_as_provided]
+                    with open(vyper_custom_std_json_in) as custom:
+                        custom_json = json.load(custom)
+                        sources_dict = custom_json.get("sources", None)
+                        search_paths_arr = custom_json.get("settings", {}).get("search_paths", None)
+                        additional_asts = [x for x, _ in sources_dict.items() if x.endswith(".vy")]
+                if not sources_dict:
+                    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"]
+        else:
+            # "non-compilable" language so no need to deal with it
+            fatal_error(compiler_logger, "Expected only Solidity and Vyper as "
+                                         "languages for which we build a standard-json")
 
         settings_dict: Dict[str, Any] = \
             {
                 "remappings": remappings,
                 "outputSelection": {
-                    "*": {
+                    main_contract_for_output_selection: {
                         "*": output_selection,
                         "": ast_selection
                     }
                 }
             }
+        if search_paths_arr:
+            settings_dict["search_paths"] = search_paths_arr
+        if additional_asts:
+            for p in additional_asts:
+                if p != main_contract_for_output_selection:
+                    settings_dict["outputSelection"][p] = {"": ["ast"]}
 
         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")
         # debug_print(json.dumps(result_dict, indent=4))
         return result_dict
@@ -1881,7 +1925,7 @@ class CertoraBuildGenerator:
                               compiler_input=standard_json_input)
 
         compiler_logger.debug(f"Collecting standard json: {collect_cmd}")
-        standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang)
+        standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang, compiler_collector)
 
         for error in standard_json_data.get("errors", []):
             # is an error not a warning
@@ -1890,8 +1934,10 @@ class CertoraBuildGenerator:
                 # 6275 the error code of solc compiler for missing file
                 if 'errorCode' in error and error['errorCode'] == '6275':
                     print_package_file_note()
+
+                error_msg = error.get("formattedMessage", error.get("message", "[no msg]"))
                 friendly_message = f"{compiler_ver_to_run} had an error:\n" \
-                                   f"{error['formattedMessage']}"
+                                   f"{error_msg}"
                 if fail_on_compilation_error:
                     raise Util.CertoraUserInputError(friendly_message)
                 else:
@@ -1900,16 +1946,20 @@ class CertoraBuildGenerator:
                     raise Util.SolcCompilationException(friendly_message)
 
         # load data
-        data = \
-            smart_contract_lang.collect_storage_layout_info(file_abs_path, compilation_path, compiler_ver_to_run,
-                                                            compiler_collector.compiler_version,
-                                                            standard_json_data)  # Note we collected for just ONE file
+        # In vyper, we first need the ASTs. Then collect_storage_layout_info will add
+        # storage layout keys for vyper and do nothing for solidity,
+        data = standard_json_data
         self.check_for_errors_and_warnings(data, fail_on_compilation_error)
         if smart_contract_lang.supports_ast_output:
             self.collect_asts(build_arg_contract_file, data["sources"])
+        data = \
+            smart_contract_lang.collect_storage_layout_info(file_abs_path, compilation_path, compiler_ver_to_run,
+                                                            compiler_collector.compiler_version,
+                                                            data, self.asts.get(build_arg_contract_file, {}),
+                                                            build_arg_contract_file)  # Note we collected for just ONE file
 
         contracts_with_libraries = {}
-        file_compiler_path = smart_contract_lang.normalize_file_compiler_path_name(file_abs_path)
+        file_compiler_path = compiler_collector.normalize_file_compiler_path_name(file_abs_path)
 
         # But apparently this heavily depends on the Solidity AST format anyway
 
@@ -2263,15 +2313,10 @@ class CertoraBuildGenerator:
                 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")
+            symbol_map_name = metadata_func_info["_ir_identifier"] + "_runtime"
+            if symbol_map_name not in symbol_map:
                 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]]
+            vyper_metadata.runtime_start_pc = symbol_map[symbol_map_name]
             internal_func.vyper_metadata = vyper_metadata
 
     def get_contract_in_sdc(self,
@@ -3292,6 +3337,9 @@ class CertoraBuildGenerator:
                 })
         return result
 
+    def _needs_casting_instrumentation(self) -> bool:
+        return self.context.safe_casting_builtin or self.context.assume_no_casting_overflow
+
     def instrument_auto_finders(self, build_arg_contract_file: str, i: int,
                                 sdc_pre_finders: List[SDC],
                                 path_for_compiler_collector_file: str,
@@ -3339,14 +3387,35 @@ class CertoraBuildGenerator:
         else:
             added_source_finders = {}
 
-        if self.context.safe_casting_builtin:
+        offset_converters = generate_offset_converters(sdc_pre_finder)
+
+        if self._needs_casting_instrumentation():
             try:
-                casting_instrumentations, casting_types = generate_casting_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder)
+                casting_instrumentations, casting_types = generate_casting_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder, offset_converters)
             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)
+                instrumentation_logger.warning(f"Computing casting instrumentation failed for {build_arg_contract_file}: {e}", exc_info=True)
+        else:
+            casting_instrumentations, casting_types = {}, {}
+
+        if self.context.unchecked_overflow_builtin:
+            try:
+                overflow_instrumentations, op_funcs = generate_overflow_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder, offset_converters)
+            except Exception as e:
+                overflow_instrumentations, op_funcs = {}, {}
+                instrumentation_logger.warning(
+                    f"Computing overflow instrumenstation failed for {build_arg_contract_file}: {e}", exc_info=True)
+        else:
+            overflow_instrumentations, op_funcs = {}, {}
+
+        for file_name, inst_dict in casting_instrumentations.items():
+            if file_name not in overflow_instrumentations:
+                overflow_instrumentations[file_name] = dict()
+            d = overflow_instrumentations[file_name]
+            for offset, inst in inst_dict.items():
+                add_instrumentation(d, offset, inst)
+
+        instr = CertoraBuildGenerator.merge_dicts_instrumentation(instr, overflow_instrumentations)
 
         abs_build_arg_contract_file = Util.abs_posix_path(build_arg_contract_file)
         if abs_build_arg_contract_file not in instr:
@@ -3401,7 +3470,7 @@ class CertoraBuildGenerator:
                         read_so_far += amt + 1 + to_skip
                     output.write(in_file.read(-1))
 
-                    if self.context.safe_casting_builtin:
+                    if self._needs_casting_instrumentation():
                         library_name, funcs = casting_types.get(contract_file, ("", list()))
                         if len(funcs) > 0:
                             output.write(bytes(f"\nlibrary {library_name}" + "{\n", "utf8"))
@@ -3409,6 +3478,13 @@ class CertoraBuildGenerator:
                                 output.write(bytes(f, "utf8"))
                             output.write(bytes("}\n", "utf8"))
 
+                    library_name, funcs = op_funcs.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]
@@ -3429,6 +3505,7 @@ class CertoraBuildGenerator:
                     f"Compiling {orig_file_name} to expose internal function information and local variables...")
             else:
                 Util.print_progress_message(f"Compiling {orig_file_name} to expose internal function information...")
+
             # record what aliases we have created (for the purposes of type canonicalization, the generated autofinder
             # is an alias of the original file)
             for k, v in autofinder_remappings.items():

certora_cli/CertoraProver/certoraContextAttributes.py

@@ -326,6 +326,23 @@ class EvmAttributes(AttrUtil.Attributes):
         )
     )
 
+    VYPER_CUSTOM_STD_JSON_IN_MAP = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.MAP,
+        attr_validation_func=Vf.validate_vyper_custom_std_json_in_map,
+        help_msg="Supply a base json for getting vyper compiler output, generated by `vyper -f solc_json`, on a per"
+                 "contract basis",
+        default_desc="It is assumed the standard-json generated by certora-cli will be able to compile the contracts",
+        argparse_args={
+            "action": AttrUtil.UniqueStore,
+            "type": lambda value: Vf.parse_ordered_dict("validate_vyper_custom_std_json_in_map", value)
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+        config_data=AttributeJobConfigData(
+            main_section=MainSection.SOLIDITY_COMPILER
+        )
+    )
+
     SOLC_VIA_IR = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
         help_msg="Pass the `--via-ir` flag to the Solidity compiler",
@@ -1216,7 +1233,7 @@ class EvmAttributes(AttrUtil.Attributes):
     SAFE_CASTING_BUILTIN = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
         help_msg="This needs to be set to true for the safeCasting builtin to work",
-        default_desc="This needs to be set to true for the safeCasting builtin to work",
+        default_desc="safeCasting builtin will not run",
         jar_flag='-safeCastingBuiltin',
         argparse_args={
             'action': AttrUtil.STORE_TRUE,
@@ -1226,6 +1243,45 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False,
     )
 
+    ASSUME_NO_CASTING_OVERFLOW = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        help_msg="Will Assume solidity casting expressions never overflow",
+        default_desc="Solidity casting expressions may overflow",
+        jar_flag='-assumeNoCastingOverflow',
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE,
+            'default': False
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+    )
+
+    UNCHECKED_OVERFLOW_BUILTIN = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        help_msg="This needs to be set to true for the uncheckedOverflow builtin to work",
+        default_desc="uncheckedOverflow builtin will not run",
+        jar_flag='-uncheckedOverflowBuiltin',
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE,
+            'default': False
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+    )
+
+    CONTRACT_EXTENSIONS_OVERRIDE = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        help_msg="Set this flag if you are using `contract_extensions` and an extending contract has a method that should override a method with the same name in the extension contract",
+        default_desc="Prover will fail if an extending contract has a method with the same name as one in the extended contract that wasn't excluded.",
+        jar_flag='-overrideExtendedContractFunctions',
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE,
+            'default': False
+        },
+        affects_build_cache_key=False,
+        disables_build_cache=False,
+    )
+
     @classmethod
     def hide_attributes(cls) -> List[str]:
         # do not show these attributes in the help message

certora_cli/CertoraProver/certoraContextValidator.py

@@ -750,7 +750,14 @@ def check_map_attributes(context: CertoraContext) -> None:
 
         none_keys = [k for k, v in file_list.items() if v is False]
         if none_keys:
-            raise Util.CertoraUserInputError(f"The following files are not matched in {map_attr_name}: {none_keys}")
+            if map_attr_name == Attrs.EvmAttributes.VYPER_CUSTOM_STD_JSON_IN_MAP.name.lower():
+                # this new attribute requires special handling in case we combine solidity files with vyper0.4 files
+                vy_files_unmatched = [k for k in none_keys if Util.is_vyper_file(k)]
+                if vy_files_unmatched:
+                    raise Util.CertoraUserInputError(
+                        f"The following vyper files are not matched in {map_attr_name}: {none_keys}")
+            else:
+                raise Util.CertoraUserInputError(f"The following files are not matched in {map_attr_name}: {none_keys}")
 
 
 def check_parametric_contracts(context: CertoraContext) -> None:

certora_cli/CertoraProver/certoraContractFuncs.py

@@ -52,7 +52,7 @@ class VyperMetadata:
         frame_size: Optional[int] = None,
         frame_start: Optional[int] = None,
         venom_via_stack: Optional[List[str]] = None,
-        venom_return_via_stack: bool = False,
+        venom_return_via_stack: Optional[bool] = None,
         runtime_start_pc: Optional[int] = None,
     ):
         self.frame_size = frame_size

certora_cli/CertoraProver/certoraOffsetConverter.py

@@ -0,0 +1,54 @@
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import bisect
+from pathlib import Path
+
+from CertoraProver.certoraBuildDataClasses import SDC
+from Shared import certoraUtils as Util
+
+
+class OffsetConverter:
+    """Holds newline positions for a file to enable offset-to-line-column conversion."""
+
+    def __init__(self, file: str):
+        """Initialize OffsetConverter by reading newline positions from a file."""
+        with Path(file).open('rb') as f:
+            content = f.read()
+        self.newline_positions = [i for i, byte in enumerate(content) if byte == ord(b'\n')]
+
+    def offset_to_line_column(self, offset: int) -> tuple[int, int]:
+        """
+        Convert a file offset to line and column number.
+
+        Args:
+            offset: Byte offset in the file
+
+        Returns:
+            Tuple of (line_number, column_number), both 1-indexed
+        """
+        line = bisect.bisect_left(self.newline_positions, offset)
+        # Calculate column based on previous newline position
+        if line == 0:
+            column = offset + 1  # 1-indexed, no previous newline
+        else:
+            column = offset - self.newline_positions[line - 1]  # 1-indexed from newline
+        return line, column
+
+
+def generate_offset_converters(sdc: SDC) -> dict[str, OffsetConverter]:
+    original_files = {Util.convert_path_for_solc_import(c.original_file) for c in sdc.contracts}
+    return {file: OffsetConverter(file) for file in original_files}

certora_cli/CertoraProver/certoraSourceFinders.py

@@ -291,17 +291,17 @@ def is_unsupported_type(type_string: str) -> bool:
     return type_string not in PrimitiveType.allowed_primitive_type_names
 
 
-def find_semicolon(filepath: str, offset: int) -> Optional[int]:
+def find_char(filepath: str, offset: int, c : str) -> Optional[int]:
     """
-    From given offset, skip whitespace until finding a semicolon.
-    Returns None if any non-whitespace character other than ';' is encountered.
+    given offset, skip whitespace until finding the input character `c`.
+    Returns None if any non-whitespace character other than `c` is encountered.
 
     Args:
         filepath: Path to the file
-        offset: Byte offset where we expect to find ';' or whitespace
+        offset: Byte offset where we expect to find 'c' or whitespace
 
     Returns:
-        Offset of the semicolon if found after only whitespace
+        Offset of 'c' if found after only whitespace
         None if any other non-whitespace character is encountered
     """
     try:
@@ -312,7 +312,7 @@ def find_semicolon(filepath: str, offset: int) -> Optional[int]:
                 if not char:  # EOF
                     return None
 
-                if char == ';':
+                if char == c:
                     return f.tell() - 1
 
                 if char not in ' \t\n\r':  # not whitespace
@@ -366,7 +366,7 @@ def add_source_finders(asts: Dict[str, Dict[str, Dict[int, Any]]], contract_file
             # no need to -1 as the source mapping does not include the ';', and we want to find it...
             # i.e., the end_offset should point at ';'
             end_offset = int(start_offset) + int(src_len)  # this is the original end offset
-            end_offset_with_semicolon = find_semicolon(solfile, end_offset)
+            end_offset_with_semicolon = find_char(solfile, end_offset, ";")
             if end_offset_with_semicolon is None:
                 # we are dealing with Solidity code with unexpected format, let's skip this assignment
                 continue