certora-cli-beta-mirror 8.6.3__py3-none-macosx_10_9_universal2.whl → 8.7.0__py3-none-macosx_10_9_universal2.whl

certora_cli/CertoraProver/Compiler/CompilerCollector.py

@@ -66,13 +66,6 @@ class CompilerLang(metaclass=AbstractAndSingleton):
         """
         return func_hash
 
-    @staticmethod
-    def normalize_file_compiler_path_name(file_abs_path: str) -> str:
-        """
-        Normalizes the absolute path name [file_abs_path] of a file, given to the compiler.
-        """
-        return file_abs_path
-
     @staticmethod
     def normalize_deployed_bytecode(deployed_bytecode: str) -> str:
         """
@@ -114,7 +107,9 @@ class CompilerLang(metaclass=AbstractAndSingleton):
                                     config_path: Path,
                                     compiler_cmd: str,
                                     compiler_version: Optional[CompilerVersion],
-                                    data: Dict[str, Any]) -> Dict[str, Any]:
+                                    data: Dict[str, Any],
+                                    asts :  Dict[str, Dict[int, Any]],
+                                    ast_key: str) -> Dict[str, Any]:
         """
         Returns the data dictionary of the contract with storage layout information if needed
         """
@@ -195,5 +190,11 @@ class CompilerCollector(ABC):
     def compiler_version(self) -> CompilerVersion:
         pass
 
+    def normalize_file_compiler_path_name(self, file_abs_path: str) -> str:
+        """
+        Normalizes the absolute path name [file_abs_path] of a file, given to the compiler.
+        """
+        return file_abs_path
+
     def __str__(self) -> str:
         return f"{self.compiler_name} {self.compiler_version}"

certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py

@@ -52,12 +52,6 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         except ValueError:
             raise Exception(f'{func_hash} is not convertible to hexadecimal')
 
-    @staticmethod
-    def normalize_file_compiler_path_name(file_abs_path: str) -> str:
-        if not file_abs_path.startswith('/'):
-            return '/' + file_abs_path
-        return file_abs_path
-
     @staticmethod
     def normalize_deployed_bytecode(deployed_bytecode: str) -> str:
         assert deployed_bytecode.startswith("0x"), f'expected {deployed_bytecode} to have hexadecimal prefix'
@@ -785,10 +779,10 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         return [t.resolve_forward_declared_types(name_resolution_dict) for t in real_types]
 
     @staticmethod
-    def extract_ast_types_and_public_vardecls(ast_body_nodes: Dict[int, Dict[str, Any]]) -> \
+    def extract_ast_types_and_public_vardecls(ast_body_nodes_per_file: Dict[str, Dict[int, Dict[str, Any]]]) -> \
             Tuple[List[VyperType], Dict[str, VyperType]]:
         """
-        :param ast_body_nodes:
+        :param ast_body_nodes_per_file:
         :return: (types, vars) where `types` is a list of all user-defined types, and `vars` maps public variables to
           their output types.  Note that `types` has been fully resolved - all `VyperTypeNameReference` nodes have been
           dereferenced
@@ -805,38 +799,50 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
         # Process named constants ahead of time, as their use site in the source may precede
         # their definition site, e.g.
-        for ast_node in ast_body_nodes.values():
-            if ast_node['ast_type'] != 'VariableDecl':
-                continue
-            if ast_node['is_constant'] and ast_node['value'] is not None and \
-               (ast_node['value']['ast_type'] == 'Int'):
-                named_constants.update({ast_node['target']['id']: int(ast_node['value']['value'])})
-
-        for ast_node in ast_body_nodes.values():
-            if ast_node['ast_type'] == 'VariableDecl':
-                decltype = CompilerLangVy.extract_type_from_variable_decl(ast_node, named_constants)
-                result_types.append(decltype)
-                if ast_node['is_public']:
-                    public_vardecls[ast_node['target']['id']] = decltype
-            elif ast_node['ast_type'] == 'StructDef':
-                result_types.append(CompilerLangVy.extract_type_from_struct_def(ast_node, named_constants))
-            # Not sure if `Import` is an actual ast type. It was already there, so I am not removing it.
-            # I only fixed the implementation of this case to what I think it should be.
-            elif ast_node['ast_type'] == 'Import':
-                result_types.append(CompilerLangVy.VyperTypeContract(ast_node['name']))
-            elif ast_node['ast_type'] == 'ImportFrom':
-                result_types.append(CompilerLangVy.VyperTypeContract(ast_node['name']))
-            elif ast_node['ast_type'] == 'InterfaceDef':
-                result_types.append(CompilerLangVy.VyperTypeContract(ast_node['name']))
-        resolved_result_types = CompilerLangVy.resolve_extracted_types(result_types)
-        return resolved_result_types, resolve_vardecl_types(public_vardecls, resolved_result_types)
+        for _, ast_body_nodes in ast_body_nodes_per_file.items():
+            for ast_node in ast_body_nodes.values():
+                if ast_node['ast_type'] != 'VariableDecl':
+                    continue
+                if ast_node['is_constant'] and ast_node['value'] is not None and \
+                   (ast_node['value']['ast_type'] == 'Int'):
+                    named_constants.update({ast_node['target']['id']: int(ast_node['value']['value'])})
+
+        resolved_result_types = []
+        for _, ast_body_nodes in ast_body_nodes_per_file.items():
+            for ast_node in ast_body_nodes.values():
+                if ast_node['ast_type'] == 'VariableDecl':
+                    decltype = CompilerLangVy.extract_type_from_variable_decl(ast_node, named_constants)
+                    result_types.append(decltype)
+                    if ast_node['is_public']:
+                        public_vardecls[ast_node['target']['id']] = decltype
+                elif ast_node['ast_type'] == 'StructDef':
+                    result_types.append(CompilerLangVy.extract_type_from_struct_def(ast_node, named_constants))
+                # Not sure if `Import` is an actual ast type. It was already there, so I am not removing it.
+                # I only fixed the implementation of this case to what I think it should be.
+                elif ast_node['ast_type'] in ['Import', 'ImportFrom']:
+                    if "name" in ast_node:
+                        result_types.append(CompilerLangVy.VyperTypeContract(ast_node['name']))
+                    elif "names" in ast_node:
+                        n_list = ast_node["names"]
+                        for t in n_list:
+                            result_types.append(CompilerLangVy.VyperTypeContract(t["name"]))
+                    else:
+                        raise Exception("Unrecognized import node")
+                elif ast_node['ast_type'] == 'InterfaceDef':
+                    result_types.append(CompilerLangVy.VyperTypeContract(ast_node['name']))
+            resolved_result_types.extend(CompilerLangVy.resolve_extracted_types(result_types))
+
+        # SG: I'm not sure why we didn't set it as a set to begin with. Punting for now
+        return list(set(resolved_result_types)), resolve_vardecl_types(public_vardecls, resolved_result_types)
 
     @staticmethod
     def collect_storage_layout_info(file_abs_path: str,
                                     config_path: Path,
                                     compiler_cmd: str,
                                     compiler_version: Optional[CompilerVersion],
-                                    data: Dict[str, Any]) -> Dict[str, Any]:
+                                    data: Dict[str, Any],
+                                    asts : Dict[str, Dict[int, Any]],
+                                    ast_key: str) -> Dict[str, Any]:
         # only Vyper versions 0.2.16 and up have the storage layout
         if compiler_version is None or not CompilerCollectorVy.supports_storage_layout(compiler_version):
             return data
@@ -872,20 +878,6 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
                     print(f'Error: {e}')
                     print_failed_to_run(compiler_cmd)
                     raise
-        ast_output_file_name = f'{get_certora_config_dir()}.ast'
-        ast_stdout_name = storage_layout_output_file_name + '.stdout'
-        ast_stderr_name = storage_layout_output_file_name + '.stderr'
-        args = [compiler_cmd, '-f', 'ast', '-o', ast_output_file_name, file_abs_path]
-        with Path(ast_stdout_name).open('w+') as stdout:
-            with Path(ast_stderr_name).open('w+') as stderr:
-                try:
-                    subprocess.run(args, stdout=stdout, stderr=stderr)
-                    with Path(ast_output_file_name).open('r') as output_file:
-                        ast_dict = json.load(output_file)
-                except Exception as e:
-                    print(f'Error: {e}')
-                    print_failed_to_run(compiler_cmd)
-                    raise
 
         # Depressing how many bugs old Vyper had. Example:
         # vyper 0.3.7: "userBalances": {"type": "HashMap[address, uint256]", "slot": 1}
@@ -893,10 +885,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         #                               "location": "storage", "slot": 2}
         # so we'll just gracefully exit
         try:
-
-            extracted_types, _ = CompilerLangVy.extract_ast_types_and_public_vardecls(
-                {x['node_id']: x for x in ast_dict['ast']['body']}
-            )
+            extracted_types, _ = CompilerLangVy.extract_ast_types_and_public_vardecls(asts)
             all_used_types = list(itertools.chain.from_iterable([e.get_used_types() for e in extracted_types])) + \
                 list(CompilerLangVy.primitive_types.values())
             type_descriptors_by_name = {i.get_canonical_vyper_name(): i.get_storage_type_descriptor()
@@ -931,22 +920,63 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
                 return desc
 
-            storage_field = [{
-                'label': v,
-                'slot': str(storage_layout_dict[v]['slot']),
-                'offset': 0,
-                'type': storage_layout_dict[v]['type'],
-                'descriptor': annotate_desc(type_descriptors_by_name[storage_layout_dict[v]['type']],
-                                            storage_layout_dict[v]['type'], types_field)
-            } for v in storage_layout_dict.keys()]
-
-            contract_name = list(data['contracts'][file_abs_path].keys())[0]
-            data['contracts'][file_abs_path][contract_name]['storageLayout'] = {
+            def extract_storage_fields(storage_layout_dict: Dict[str, Any],
+                                       type_descriptors_by_name: Dict[str, Dict[str, Any]],
+                                       types_field: Dict[str, Dict[str, Any]],
+                                       parent_path: str = "") -> List[Dict[str, Any]]:
+                """
+                Recursively traverse storage layout dictionary and extract all fields with 'slot' keys.
+
+                Args:
+                    storage_layout_dict: The storage layout dictionary to traverse
+                    type_descriptors_by_name: Type descriptors mapping
+                    types_field: Types field for annotation
+                    parent_path: Current path in the hierarchy (for building field labels)
+
+                Returns:
+                    List of storage field dictionaries
+                """
+                storage_fields = []
+
+                for key, value in storage_layout_dict.items():
+                    current_path = f"{parent_path}.{key}" if parent_path else key
+
+                    if isinstance(value, dict):
+                        # Check if this dict contains a 'slot' key (leaf node)
+                        if 'slot' in value:
+                            # This is a storage variable - process it
+                            storage_fields.append({
+                                'label': current_path,
+                                'slot': str(value['slot']),
+                                'offset': 0,
+                                'type': value['type'],
+                                'descriptor': annotate_desc(
+                                    type_descriptors_by_name[value['type']],
+                                    value['type'],
+                                    types_field
+                                )
+                            })
+                        else:
+                            # This is a nested structure - recurse into it
+                            storage_fields.extend(
+                                extract_storage_fields(value, type_descriptors_by_name, types_field, current_path)
+                            )
+
+                return storage_fields
+
+            storage_field = extract_storage_fields(storage_layout_dict, type_descriptors_by_name, types_field)
+
+            data_key = file_abs_path if file_abs_path in data["contracts"] else ast_key
+            if data_key not in data["contracts"]:
+                raise Exception(f"Expected to have the right key into the json out for updating the storage layout, "
+                                f"tried {file_abs_path} and {ast_key} but keys are {data['contracts'].keys()}")
+            contract_name = list(data['contracts'][data_key].keys())[0]
+            data['contracts'][data_key][contract_name]['storageLayout'] = {
                 'storage': storage_field,
                 'types': types_field,
                 'storageHashArgsReversed': True
             }
-            data['contracts'][file_abs_path][contract_name]['storageHashArgsReversed'] = True
+            data['contracts'][data_key][contract_name]['storageHashArgsReversed'] = True
             return data
         except Exception as e:
             ast_logger.warning(f'Failed to get storage layout, continuing: {e}')
@@ -1175,7 +1205,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             return funcs
 
         vyper_types, public_vardecls = \
-            CompilerLangVy.extract_ast_types_and_public_vardecls(asts[build_arg_contract_file][contract_file])
+            CompilerLangVy.extract_ast_types_and_public_vardecls(asts[build_arg_contract_file])
         ct_types = [x.get_certora_type(contract_name, 0) for x in vyper_types]
         getter_vars_list = [(v, public_vardecls[v].get_certora_type(contract_name, 0))
                             for v in public_vardecls if isinstance(public_vardecls[v], CompilerLangVy.VyperTypeHashMap)]
@@ -1208,7 +1238,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
         try:
             # TODO: verify that the collected functions matches the information in data['abi']
-            collector = Collector(contract_name, asts[build_arg_contract_file][contract_file])
+            collector = Collector(contract_name, asts[build_arg_contract_file])
             type_descriptions_and_funcs = [t.get_certora_type(contract_name, 0) for t in
                                            collector.types.values()], collector.funcs
 
@@ -1249,17 +1279,24 @@ class Collector:
 
     _contract_name : str
 
-    def __init__(self, contract_name : str, asts: Dict[int, Dict[str, Any]]):
+    def __init__(self, contract_name : str, asts_per_file: Dict[str, Dict[int, Dict[str, Any]]]):
         """Collect the types and functions from the top-level 'AST' node in [ast]."""
         self.types = {}
         self.funcs = []
         self.consts = {}
         self._contract_name = contract_name
-        for node in asts.values():
-            if node['ast_type'] == 'Module':
-                self._collect_module(node)
-
-    def _collect_module(self, module_node: Dict[str, Any]) -> None:
+        # first pass - get all constants
+        for _, asts in asts_per_file.items():
+            for node in asts.values():
+                if node['ast_type'] == 'Module':
+                    self._collect_module_consts(node)
+
+        for _, asts in asts_per_file.items():
+            for node in asts.values():
+                if node['ast_type'] == 'Module':
+                    self._collect_module(node)
+
+    def _collect_module_consts(self, module_node: Dict[str, Any]) -> None:
         """Populate [self.types] and [self.funcs] base on 'Module' AST node in [node]."""
         assert module_node['ast_type'] == "Module"
 
@@ -1272,6 +1309,7 @@ class Collector:
         for v in var_decls:
             self._collect_const(v)
 
+    def _collect_module(self, module_node: Dict[str, Any]) -> None:
         # Extract and resolve types
         type_asts = {'EnumDef', 'StructDef', 'InterfaceDef', 'Import', 'Import', 'ImportFrom', 'FlagDef'}
         types = [e for e in module_node['body'] if e['ast_type'] in type_asts]
@@ -1286,6 +1324,7 @@ class Collector:
         for f in funs:
             self._collect_func(f)
 
+        var_decls = [e for e in module_node['body'] if e['ast_type'] == 'VariableDecl']
         # Add getters for public variables (also needs to happen after type resolution)
         for v in var_decls:
             self._collect_getter(v)
@@ -1308,7 +1347,16 @@ class Collector:
         # TODO: this is probably wrong, since you can probably import constants and things too...
         #   although in practice it appears that people only import constants
         elif type_decl_node['ast_type'] in ('InterfaceDef', 'Import', 'ImportFrom'):
-            vy_type = CompilerLangVy.VyperTypeContract(type_decl_node['name'])
+            if "names" in type_decl_node:
+                n_list = type_decl_node["names"]
+                for t in n_list:
+                    ty = CompilerLangVy.VyperTypeContract(t["name"])
+                    self.types[t["name"]] = ty
+                return
+            elif "name" in type_decl_node:
+                vy_type = CompilerLangVy.VyperTypeContract(type_decl_node['name'])
+            else:
+                raise AssertionError("Unexpected type definition")
         else:
             raise AssertionError("Unexpected type definition")
         self.types[type_decl_node['name']] = vy_type
@@ -1386,6 +1434,11 @@ class CompilerCollectorVy(CompilerCollector):
     def compiler_version(self) -> CompilerVersion:
         return self.__compiler_version
 
+    def normalize_file_compiler_path_name(self, file_abs_path: str) -> str:
+        if self.compiler_version[1] < 4 and not file_abs_path.startswith('/'):
+            return '/' + file_abs_path
+        return file_abs_path
+
     @staticmethod
     def supports_storage_layout(version: CompilerVersion) -> bool:
         return (version[1] > 2 or (

certora_cli/CertoraProver/castingInstrumenter.py

@@ -15,10 +15,11 @@
 
 
 from dataclasses import dataclass
-from typing import Dict, Any, Optional, Generator
+from typing import Dict, Any, Optional, Callable, Generator
 
 from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol
 from CertoraProver.certoraBuildDataClasses import SDC, Instrumentation, Replace
+from CertoraProver.certoraOffsetConverter import OffsetConverter
 from Shared import certoraUtils as Util
 
 
@@ -92,7 +93,7 @@ def find_casts(ast: Dict[int, Any]) -> list[CastInfo]:
     function_nodes = [node for node in ast.values() if node.get('nodeType') == 'FunctionDefinition']
 
     for func in function_nodes:
-        for node in iter_all_nodes(func):
+        for node in iter_all_nodes_under(func):
             if isinstance(node, dict) and node.get("kind") == "typeConversion":
                 arguments = node.get("arguments", [])
                 if len(arguments) == 1 and isinstance(arguments[0], dict):
@@ -119,19 +120,21 @@ def casting_func_name(counter: int) -> str:
     return f"cast_{counter}"
 
 
-def generate_casting_function(assembly_prefix: str, cast_info: CastInfo, counter: int) -> str:
+def generate_casting_function(assembly_prefix: str, cast_info: CastInfo, counter: int, line: int, column: int) -> str:
     """
     returns the text of a solidity function that does casting according to CastInfo. It also has an encoded mload
     call, to be decoded later on the kotlin side if we run the `safeCasting` builtin rule.
     """
-    conversion_string = assembly_prefix + \
-        "{ mstore(0xffffff6e4604afefe123321beef1b03fffffffffffffffffffff" + \
-        f'{"%0.4x" % counter}{"%0.4x" % encode_type(cast_info.arg_type_str)}{"%0.4x" % encode_type(cast_info.res_type_str)}, x)' + "}"
+    conversion_string = (assembly_prefix +
+                         "{ mstore(0xffffff6e4604afefe123321beef1b03fffffffffffffff" +
+                         f'{"%0.5x" % line}{"%0.5x" % column}{"%0.4x" % encode_type(cast_info.arg_type_str)}{"%0.4x" % encode_type(cast_info.res_type_str)}, x)'
+                         "}")
     function_head = f"function {casting_func_name(counter)}({cast_info.arg_type_str} x) internal pure returns ({cast_info.res_type_str})"
     return function_head + "{\n" + conversion_string + f"return {cast_info.res_type_str}(x);\n" "}\n"
 
 
-def generate_casting_instrumentation(asts: Dict[str, Dict[str, Dict[int, Any]]], contract_file: str, sdc: SDC) \
+def generate_casting_instrumentation(asts: Dict[str, Dict[str, Dict[int, Any]]], contract_file: str, sdc: SDC,
+                                     offset_converters: dict[str, OffsetConverter]) \
         -> tuple[Dict[str, Dict[int, Instrumentation]], Dict[str, tuple[str, list[str]]]]:
     """
     Generate instrumentation for integer type casts in Solidity code.
@@ -152,7 +155,7 @@ def generate_casting_instrumentation(asts: Dict[str, Dict[str, Dict[int, Any]]],
                         " when trying to add casting instrumentation")
     assembly_prefix = sdc.compiler_collector.gen_memory_safe_assembly_prefix()
 
-    casting_funcs : Dict[str, tuple[str, list[str]]] = dict()
+    casting_funcs: dict[str, tuple[str, list[str]]] = dict()
     counter = 0
     original_files = sorted({Util.convert_path_for_solc_import(c.original_file) for c in sdc.contracts})
     for file_count, solfile in enumerate(original_files, start=1):
@@ -165,28 +168,32 @@ def generate_casting_instrumentation(asts: Dict[str, Dict[str, Dict[int, Any]]],
         casts = find_casts(curr_file_ast)
         for cast_info in casts:
             start_offset, src_len, file = curr_file_ast[cast_info.expr_id]["src"].split(":")
+            line, column = offset_converters[solfile].offset_to_line_column(int(start_offset))
             counter += 1
             per_file_inst[int(start_offset)] = Instrumentation(expected=bytes(cast_info.res_type_str[0], 'utf-8'),
                                                                to_ins=f"{libname}.{casting_func_name(counter)}",
                                                                mut=Replace(len(cast_info.res_type_str)))
-            new_func = generate_casting_function(assembly_prefix, cast_info, counter)
+            new_func = generate_casting_function(assembly_prefix, cast_info, counter, line, column)
             per_file_casts.append(new_func)
 
     return casting_instrumentation, casting_funcs
 
 
-def iter_all_nodes(node: Any) -> Generator[Any, Optional[Any], None]:
+def iter_all_nodes_under(node: Any, f: Callable[[Any], bool] = lambda node: True, is_inside: bool = False) \
+        -> Generator[Any, Optional[Any], None]:
     """
-    Yield a node and all its subnodes in depth-first order.
+    Yield a node and all its subnodes in depth-first order, but only recursively under nodes where f returns True.
     Works with dict nodes that may contain nested dicts and lists.
     """
-    yield node
+    inside = is_inside
+    if f(node):
+        inside = True
+    if inside:
+        yield node
 
     if isinstance(node, dict):
         for value in node.values():
-            if isinstance(value, (dict, list)):
-                yield from iter_all_nodes(value)
+            yield from iter_all_nodes_under(value, f, inside)
     elif isinstance(node, list):
         for item in node:
-            if isinstance(item, (dict, list)):
-                yield from iter_all_nodes(item)
+            yield from iter_all_nodes_under(item, f, inside)

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,
@@ -3339,14 +3384,35 @@ class CertoraBuildGenerator:
         else:
             added_source_finders = {}
 
+        offset_converters = generate_offset_converters(sdc_pre_finder)
+
         if self.context.safe_casting_builtin:
             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:
@@ -3409,6 +3475,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 +3502,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,19 @@ class EvmAttributes(AttrUtil.Attributes):
         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,
+    )
+
     @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

certora_cli/CertoraProver/uncheckedOverflowInstrumenter.py

@@ -0,0 +1,152 @@
+#     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/>.
+from typing import Any
+
+from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol
+from CertoraProver.castingInstrumenter import encode_type, iter_all_nodes_under
+from CertoraProver.certoraBuildDataClasses import SDC, Instrumentation, Replace, InsertBefore, InsertAfter
+from CertoraProver.certoraOffsetConverter import OffsetConverter
+from CertoraProver.certoraSourceFinders import find_char
+from Shared import certoraUtils as Util
+
+
+def is_unchecked_block(node: Any) -> bool:
+    return isinstance(node, dict) and node.get('nodeType') == 'UncheckedBlock'
+
+
+def is_possibly_overflowing_op(node: Any) -> bool:
+    return isinstance(node, dict) and node.get('operator') in {"*", "+", "-"}
+
+
+def find_unchecked(ast: dict[int, Any]) -> list[dict]:
+    function_nodes = [node for node in ast.values() if node.get('nodeType') == 'FunctionDefinition']
+    result = []
+    for func in function_nodes:
+        for node in iter_all_nodes_under(func, is_unchecked_block):
+            if is_possibly_overflowing_op(node):
+                result.append(node)
+    return result
+
+
+def func_name(counter: int) -> str:
+    return f"op_{counter}"
+
+
+def char_at(filepath: str, offset: int) -> str:
+    with open(filepath, 'r') as f:
+        f.seek(offset)
+        return f.read(1)
+
+
+def instrumentations(filename: str, lib_name: str, op: dict, counter: int) -> dict[int, Instrumentation]:
+    start_offset, src_len, file = op["src"].split(":")
+    left = op["leftExpression"]
+    operator = op["operator"]
+    result: dict[int, Instrumentation] = {}
+
+    start_offset_left, src_len_left, _ = left["src"].split(":")
+    where = find_char(filename, int(start_offset_left) + int(src_len_left), operator)
+    if where is None:
+        raise Exception(f"Could not find {start_offset_left}:{src_len_left} in {filename}")
+    result[where] = Instrumentation(expected=bytes(operator, 'utf-8'),
+                                    to_ins=",",
+                                    mut=Replace(1))
+    before = int(start_offset_left)
+    result[before] = Instrumentation(expected=bytes(char_at(filename, before), 'utf-8'),
+                                     to_ins=f"{lib_name}.{func_name(counter)}(",
+                                     mut=InsertBefore())
+    after = int(start_offset) + int(src_len)
+    result[after] = Instrumentation(expected=bytes(char_at(filename, after), 'utf-8'),
+                                    to_ins=")",
+                                    mut=InsertBefore())
+    return result
+
+
+def generate_overflow_function(offset_converter: OffsetConverter, assembly_prefix: str, op: dict, counter: int) -> str:
+    res_type = op["typeDescriptions"]["typeString"]
+    function_head = f"function {func_name(counter)}({res_type} x, {res_type} y) internal pure returns ({res_type})"
+    start_offset, _, _ = op["src"].split(":")
+    _, left_length, _ = op["leftExpression"]["src"].split(":")
+    line, column = offset_converter.offset_to_line_column(int(start_offset) + int(left_length))
+    encoded = ("0xffffff6e4604afefe123321beef1b04fffffffffffffffffff"
+               f"{'%0.5x' % line}{'%0.5x' % column}{'%0.4x' % encode_type(res_type)}")
+    return f"""
+               {function_head} {{
+                 unchecked {{
+                   {res_type} z = x {op['operator']} y;
+                   {assembly_prefix} {{
+                     mstore({encoded}, z)
+                   }}
+                   return z;
+                 }}
+               }}
+           """
+
+
+def add_instrumentation(inst_dict: dict[int, Instrumentation], k: int, v: Instrumentation) -> None:
+    if k in inst_dict:
+        old = inst_dict[k]
+        if isinstance(old.mut, InsertBefore) and isinstance(v.mut, InsertBefore):
+            inst_dict[k] = Instrumentation(expected=old.expected, mut=InsertBefore(),
+                                           to_ins=old.to_ins + v.to_ins)
+        elif isinstance(old.mut, InsertAfter) and isinstance(v.mut, InsertAfter):
+            inst_dict[k] = Instrumentation(expected=old.expected, mut=InsertAfter(),
+                                           to_ins=old.to_ins + v.to_ins)
+        elif isinstance(old.mut, Replace) and isinstance(v.mut, InsertBefore):
+            inst_dict[k] = Instrumentation(expected=old.expected, mut=old.mut,
+                                           to_ins=v.to_ins + old.to_ins)
+        elif isinstance(old.mut, InsertBefore) and isinstance(v.mut, Replace):
+            inst_dict[k] = Instrumentation(expected=old.expected, mut=v.mut,
+                                           to_ins=old.to_ins + v.to_ins)
+        else:
+            print(f"GOT A PROBLEM at {k} ::::  {old}   {v}")
+            # should warn here.
+            inst_dict[k] = v
+    else:
+        inst_dict[k] = v
+
+
+def generate_overflow_instrumentation(asts: dict[str, dict[str, dict[int, Any]]], contract_file: str, sdc: SDC,
+                                      offset_converters: dict[str, OffsetConverter]) \
+        -> tuple[dict[str, dict[int, Instrumentation]], dict[str, tuple[str, list[str]]]]:
+    """
+    Generates the instrumentation for uncheckedOverflow builtin rule.
+    It replaces each of the possibly overflowing operations: `*, +, -`, with a function call to a new function
+    we add in a library in the same file. This function does the exact same operation, but adds an mload instruction
+    encoding the location of the operation and the expected resulting type.
+    """
+    overflow_instrumentation: dict[str, dict[int, Instrumentation]] = dict()
+    op_funcs: dict[str, tuple[str, list[str]]] = dict()
+    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 casting instrumentation")
+    assembly_prefix = sdc.compiler_collector.gen_memory_safe_assembly_prefix()
+    counter = 0
+
+    original_files = sorted({Util.convert_path_for_solc_import(c.original_file) for c in sdc.contracts})
+    for file_count, solfile in enumerate(original_files, start=1):
+        main_ast = asts[contract_file]
+        libname, per_file_funcs = op_funcs.setdefault(solfile, (f"CertoraOverflowLib{file_count}", []))
+        curr_file_ast = main_ast.get(solfile, dict())
+        per_file_inst = overflow_instrumentation.setdefault(solfile, dict())
+
+        for op in find_unchecked(curr_file_ast):
+            counter += 1
+            for k, v in instrumentations(contract_file, libname, op, counter).items():
+                add_instrumentation(per_file_inst, k, v)
+            new_func = generate_overflow_function(offset_converters[solfile], assembly_prefix, op, counter)
+            per_file_funcs.append(new_func)
+
+    return overflow_instrumentation, op_funcs

certora_cli/Shared/certoraValidateFuncs.py

@@ -92,6 +92,7 @@ class RunSources(Util.NoValEnum):
     BENCHMARK = auto()
     LIGHT_TEST = auto()
     REPORT = auto()
+    TIMEOUTER = auto()
 
 
 class WaitForResultOptions(Util.NoValEnum):
@@ -751,6 +752,36 @@ def validate_compiler_map(args: Dict[str, str]) -> None:
                                   "solc/vyper attribute can be used instead")
 
 
+def validate_vyper_custom_std_json_in_map(args: Dict[str, str]) -> None:
+    """
+    Checks that the argument is a dictionary of the form
+    <vy_file_1>=<stdjson_in_file_1>,<vy_file_2>=<stdjson_in_file_2>,...
+    and that all vyper files are valid: they were found
+
+    :param args: argument of --vyper_custom_std_json_in
+    :raises CertoraUserInputError if the format is wrong
+    """
+    if not isinstance(args, dict):
+        raise Util.CertoraUserInputError(f"vyper custom std json in should be stored as a map (type was {type(args).__name__})")
+
+    for source_file, json_file in args.items():
+        if not Util.is_vyper_file(source_file):
+            raise Util.CertoraUserInputError(f"{source_file} does not end with {Util.VY_EXT}")
+        source_file_path = Path(source_file)
+        if not source_file_path.exists():
+            raise Util.CertoraUserInputError(f"Source vyper file {source_file} does not exist")
+
+        if not Path(json_file).exists():
+            raise Util.CertoraUserInputError(f"Custom standard-json input file {json_file} does not exist")
+
+    values = args.values()
+    first = list(values)[0]
+
+    if all(x == first for x in values):
+        validation_logger.warning("All vyper files will be compiled with the same standard-json in. "
+                                  "Usually different standard-json in files are needed")
+
+
 def validate_git_hash(git_hash: str) -> str:
     """
     Validates that correct input was inserted as a git commit hash. It must be between 1 and 40 hexadecimal digits.

{certora_cli_beta_mirror-8.6.3.dist-info → certora_cli_beta_mirror-8.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli-beta-mirror
-Version: 8.6.3
+Version: 8.7.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-beta-mirror
 Author: Certora
@@ -38,4 +38,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit c4459c1.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 70ed750.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

{certora_cli_beta_mirror-8.6.3.dist-info → certora_cli_beta_mirror-8.7.0.dist-info}/RECORD

@@ -13,9 +13,9 @@ certora_cli/certoraSorobanProver.py,sha256=SYJKz5Sw-N0bJrSa1njRCE53R9_PMz7IWLhfa
 certora_cli/certoraSuiProver.py,sha256=gRs-iihB35ZSEIQ5-hJN-wLgrHZlcfmpk76Wr6vza74,2827
 certora_cli/rustMutator.py,sha256=j1YdY5HOWQcRNbz7TOxp5c79J0YaaYHtWZ6m2mSTeGc,14865
 certora_cli/CertoraProver/__init__.py,sha256=QHNr-PJQAoyuPgTkO7gg23GRchiWSXglWNG7yLSQZvs,849
-certora_cli/CertoraProver/castingInstrumenter.py,sha256=4FDjQjnN9s8I3B9J-_G9rug9Jf3LnWnAuRngr50oTH4,7898
+certora_cli/CertoraProver/castingInstrumenter.py,sha256=maG3J0G2Bb8uT3_xA-AOo0gpBKmwhRJcEqvORD4JwNI,8412
 certora_cli/CertoraProver/certoraApp.py,sha256=7pkQnUYMzP9V-Yo0jszNV9Y9aB760Q6hMZtlcXuuRp8,1660
-certora_cli/CertoraProver/certoraBuild.py,sha256=h6lGjUyTcC0EnRCK1DXD26Qez4DEphpFjx_IoQRiuO8,231608
+certora_cli/CertoraProver/certoraBuild.py,sha256=Nc7EUrxI9w1qTAhmryZ93oIuCLx4X_8UGj22C5mQHPk,235997
 certora_cli/CertoraProver/certoraBuildCacheManager.py,sha256=DnVd7w92xjmg0DIrMgoJnCvaU0yCz7ySy0M4RiHEXEM,13648
 certora_cli/CertoraProver/certoraBuildDataClasses.py,sha256=RGeoZCS4OztfbEUak0Oq02wIPgrmAOwLBad6-_XvX8c,14936
 certora_cli/CertoraProver/certoraBuildRust.py,sha256=ZPbNp4ttRmzcKhFsgHSiHDRExNPaLOzgxTRqu23o1D0,6061
@@ -26,27 +26,29 @@ certora_cli/CertoraProver/certoraCollectRunMetadata.py,sha256=wjP6m8W2rBka15vcj4
 certora_cli/CertoraProver/certoraCompilerParameters.py,sha256=v-MIt4sDJSQ7vpEFmCt9XBkKBhdBbZuZA4PWNErJwcU,1807
 certora_cli/CertoraProver/certoraConfigIO.py,sha256=-1EhJYsiheYvyCgOOWrRCQBjqtqNXrpMKJYRq5cKJ0Y,8171
 certora_cli/CertoraProver/certoraContext.py,sha256=ezdLmR-tSDLTtokhTyS9DacnB3W64Ke_6e714Vuug3c,29196
-certora_cli/CertoraProver/certoraContextAttributes.py,sha256=3NCjyNAkEI9ZVQD1BsNBoyHDeAYSbWWBN1gKkj-PqsA,73180
+certora_cli/CertoraProver/certoraContextAttributes.py,sha256=3LDHlGcSm44CkuuAmp9xk7juF3-aYyGpKi6kaFRmIP4,74469
 certora_cli/CertoraProver/certoraContextClass.py,sha256=d7HDqM72K7YnswR7kEcAHGwkFNrTqRz5-_0m7cl2Mso,900
-certora_cli/CertoraProver/certoraContextValidator.py,sha256=II5xHZH5j2LIZ7XP08uybzAZ-HcW778qXcS7qhMAyv8,46901
-certora_cli/CertoraProver/certoraContractFuncs.py,sha256=IKe4xbDh0yFoYVCuLeAxnGg9h59rQCla3Qpy0GwS3HE,8236
+certora_cli/CertoraProver/certoraContextValidator.py,sha256=_dIga4q2r2_q4Nk9T9dolfHfRbeKpMpJRZx0KR0zdI0,47415
+certora_cli/CertoraProver/certoraContractFuncs.py,sha256=1CAA7Y9OEmdV-8Qlwk3SxEuOPBd15cd4T5lSv4NPYY8,8245
 certora_cli/CertoraProver/certoraExtensionInfo.py,sha256=YlShzdoqJQgXXj3r0TJ3fir1KntIR99Rk8JN5qii2lk,2026
 certora_cli/CertoraProver/certoraJobList.py,sha256=FBIYgJ60I0Ok7vchfTbcuJJbiXgnfAhrONoVeZoHti4,11464
 certora_cli/CertoraProver/certoraMiniSpecParser.py,sha256=NjjMwf5Rav3YWpoOJh4PZ-QOS8exC2cg4yIBSbZA6l0,9660
 certora_cli/CertoraProver/certoraNodeFilters.py,sha256=5Uk2mixZKeis_JVd3HkLgoEVklkAYBXAZiNHRlXOIfY,2830
+certora_cli/CertoraProver/certoraOffsetConverter.py,sha256=Z3ENmJQJpbBhb_Jyb9s-z27f4bV9ABzXrDweBySRWjs,2103
 certora_cli/CertoraProver/certoraParseBuildScript.py,sha256=l7KQA1poEjmbmuYbMskz0jOQg6cW0lM3vk5ruAGPjPI,4863
 certora_cli/CertoraProver/certoraProjectScanner.py,sha256=jT7FeWzcy8o83LrZRwsg_L4x6im6Fm_0LZFKVbKr3Jk,6862
-certora_cli/CertoraProver/certoraSourceFinders.py,sha256=qwJtwrQq3NUNYmdmn1UmANN4lmJFIUh4M-St2x1FJ2Y,19038
+certora_cli/CertoraProver/certoraSourceFinders.py,sha256=UwM4ROH-QML1mD0eF_dKRZysL__CxwM-6mxhRFsXCfg,19037
 certora_cli/CertoraProver/certoraType.py,sha256=inwaLkMVwtJnwkyQhDJs-wRxoyytu2Xa_BJ5MdGlZqY,29737
 certora_cli/CertoraProver/certoraVerifyGenerator.py,sha256=YMuzGj2RNOnADOx8UnV2ys1ptw_-2mermgC9ZLMWceo,11052
 certora_cli/CertoraProver/erc7201.py,sha256=BME5kBZsDx6lgqLn7EE91I1cEOZtsnZ8BlRVF62eEBE,1660
 certora_cli/CertoraProver/splitRules.py,sha256=dNhy05ShB_-rWYTnJH5m-Xc5A4HGStAvwLRs1BTu1GA,7627
 certora_cli/CertoraProver/storageExtension.py,sha256=nrCrbH8ne-yCYSDFzh3J9A7Q6h96WxhEfLbfxGSUCSc,14363
-certora_cli/CertoraProver/Compiler/CompilerCollector.py,sha256=cr-PIl7LY9VfNs4s4H3-EnSnomPiCgXudfwP9-KenMk,6740
+certora_cli/CertoraProver/uncheckedOverflowInstrumenter.py,sha256=0zgpQR0b08tdllI2kVwWMEIcsjer0b0L10FFEvTaKm0,7446
+certora_cli/CertoraProver/Compiler/CompilerCollector.py,sha256=JX-52BQgildY2WNlDW8yBM6o6ND4cN5Ih_1t4KTHuvc,6849
 certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py,sha256=drMPTUz9cabxqIu2ngGp0x1ZZ_Jqqn-Db2qql97PTaw,8544
 certora_cli/CertoraProver/Compiler/CompilerCollectorSol.py,sha256=7nAY2FLMUlGJn4f_YoZMqpa3rf7THqhJVjLwTaChcBc,5027
 certora_cli/CertoraProver/Compiler/CompilerCollectorSolBased.py,sha256=UasYWyu8Of6R84vXsqRNGpscYcFQghmSIY_dyaAWDYA,1350
-certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py,sha256=kPzB_qbSbIFNmJd2cQ89ULwvgiGs7OdI9N_w9raaM4Y,69981
+certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py,sha256=F7BoSVE8SzKh0uID6Vqs_osPRvKK1vqsxavmpalyVUo,72953
 certora_cli/CertoraProver/Compiler/CompilerCollectorYul.py,sha256=ZTyWIMtaf4gLPRM3_jjq58Gb0r5LE_giajz6sssIi0Y,5299
 certora_cli/CertoraProver/Compiler/__init__.py,sha256=tEFAmNyx9WL0kzpp_-4s7b6pLvxHmBWz6pQAq0yeROM,789
 certora_cli/EquivalenceCheck/Eq_default.conf,sha256=J-tMFzIuQa1NcklOh-wv2bpnikfAxFogpRFOl3qoSwM,164
@@ -68,15 +70,15 @@ certora_cli/Shared/__init__.py,sha256=s0dhvolFtsS4sRNzPVhC_rlw8mm194rCZ0WhOxInY4
 certora_cli/Shared/certoraAttrUtil.py,sha256=Nw8ban5Axp6c6dT-KJfCD9i9tKnGk1DbvRDDNH3--DU,8574
 certora_cli/Shared/certoraLogging.py,sha256=cV2UQMhQ5j8crGXgeq9CEamI-Lk4HgdiA3HCrP-kSR4,14013
 certora_cli/Shared/certoraUtils.py,sha256=WEvgDMqTeqC61Q0cW1inbTmGVEgFYawjq8H2vv26bmI,60574
-certora_cli/Shared/certoraValidateFuncs.py,sha256=gCM-YP0Tpngpasd2AWxhu90UNz1wtls3WqJYp18n_Q8,43503
+certora_cli/Shared/certoraValidateFuncs.py,sha256=7m1cZVVeN1UaGdPtvjxDJBlDQF0Oq3gIkSexQsHKxuU,44893
 certora_cli/Shared/proverCommon.py,sha256=DUB-uEKjOkZ-8qil6xukPqfTynpigXW-gcrm0_kRUZY,11383
-certora_jars/ASTExtraction.jar,sha256=WW6yieuw0g2v_obN8ta_UNCo-s36aXSTalGrNlVcVlk,22010491
-certora_jars/CERTORA-CLI-VERSION-METADATA.json,sha256=X52jjlrZ6HZa4glSelbBDKPXahSrm2zQLw8TGtVuCHU,144
-certora_jars/Typechecker.jar,sha256=kCONcIoiI34Pn0MQn_cBI4Jvpxm41o0gi7syqLDWVok,21972603
+certora_jars/ASTExtraction.jar,sha256=8iuLcI3Qm-SktYtxxqbMlssniudegphVMZz9VEEwMHQ,22265115
+certora_jars/CERTORA-CLI-VERSION-METADATA.json,sha256=YXjQoHr6lx4JGa-7B4sW5gyDOiZkhpov1BtFTzi2R6U,143
+certora_jars/Typechecker.jar,sha256=FrV3Zlx8zA5vqP2k7NGy4BvK1oj9RGqu0jVIjwvIbmE,22227227
 certora_jars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-certora_cli_beta_mirror-8.6.3.dist-info/LICENSE,sha256=UGKSKIJSetF8m906JLKqNLkUS2CL60XfQdNvxBvpQXo,620
-certora_cli_beta_mirror-8.6.3.dist-info/METADATA,sha256=j_4UsqDWfNyvCbiTBjK_gU_OWAuWPpVkAxxmSy-1d28,1254
-certora_cli_beta_mirror-8.6.3.dist-info/WHEEL,sha256=9Ig2YBzm5cpS_YWKLeuYxVAxcKv_uDQsCzy9XJbRZ_g,110
-certora_cli_beta_mirror-8.6.3.dist-info/entry_points.txt,sha256=YXGQmR4tGdYD9lLdG_TEJkmVNrRauCtCDE88HwvO2Jo,569
-certora_cli_beta_mirror-8.6.3.dist-info/top_level.txt,sha256=8C77w3JLanY0-NW45vpJsjRssyCqVP-qmPiN9FjWiX4,38
-certora_cli_beta_mirror-8.6.3.dist-info/RECORD,,
+certora_cli_beta_mirror-8.7.0.dist-info/LICENSE,sha256=UGKSKIJSetF8m906JLKqNLkUS2CL60XfQdNvxBvpQXo,620
+certora_cli_beta_mirror-8.7.0.dist-info/METADATA,sha256=5uP-R_JenEwKwuLYnpFbDchACvJ4W8gjK2MIOuC2cbQ,1254
+certora_cli_beta_mirror-8.7.0.dist-info/WHEEL,sha256=9Ig2YBzm5cpS_YWKLeuYxVAxcKv_uDQsCzy9XJbRZ_g,110
+certora_cli_beta_mirror-8.7.0.dist-info/entry_points.txt,sha256=YXGQmR4tGdYD9lLdG_TEJkmVNrRauCtCDE88HwvO2Jo,569
+certora_cli_beta_mirror-8.7.0.dist-info/top_level.txt,sha256=8C77w3JLanY0-NW45vpJsjRssyCqVP-qmPiN9FjWiX4,38
+certora_cli_beta_mirror-8.7.0.dist-info/RECORD,,

certora_jars/CERTORA-CLI-VERSION-METADATA.json

@@ -1 +1 @@
-{"name": "certora-cli-beta-mirror", "tag": "8.6.3", "branch": "", "commit": "c4459c1", "timestamp": "20251218.13.53.990761", "version": "8.6.3"}
+{"name": "certora-cli-beta-mirror", "tag": "8.7.0", "branch": "", "commit": "70ed750", "timestamp": "20260121.6.14.752745", "version": "8.7.0"}