certora-cli 8.3.1__tar.gz → 8.5.1__tar.gz

{certora_cli-8.3.1/certora_cli.egg-info → certora_cli-8.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli
-Version: 8.3.1
+Version: 8.5.1
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -39,4 +39,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 33ef152.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 1738e5b.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-8.5.1/README.md

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

{certora_cli-8.3.1 → certora_cli-8.5.1}/certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py

@@ -659,7 +659,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
     @staticmethod
     def extract_type_from_enum_def(ast_enumdef_node: Dict[str, Any]) -> VyperType:
-        fields = [n['target']['id'] for n in ast_enumdef_node['body']]
+        fields = [n['target']['id'] if "target" in n else n["value"]["id"] for n in ast_enumdef_node['body']]
         return CompilerLangVy.VyperTypeEnum(ast_enumdef_node['name'], fields)
 
     @staticmethod
@@ -1273,7 +1273,7 @@ class Collector:
             self._collect_const(v)
 
         # Extract and resolve types
-        type_asts = {'EnumDef', 'StructDef', 'InterfaceDef', 'Import', 'Import', 'ImportFrom'}
+        type_asts = {'EnumDef', 'StructDef', 'InterfaceDef', 'Import', 'Import', 'ImportFrom', 'FlagDef'}
         types = [e for e in module_node['body'] if e['ast_type'] in type_asts]
         for t in types:
             self._collect_type_decl(t)
@@ -1300,7 +1300,7 @@ class Collector:
 
     def _collect_type_decl(self, type_decl_node: Dict[str, Any]) -> None:
         """Update self.types to add type definition from `type_decl_node`.  Expects self.consts to be initialized"""
-        if type_decl_node['ast_type'] == 'EnumDef':
+        if type_decl_node['ast_type'] in ('EnumDef', 'FlagDef'):
             vy_type = CompilerLangVy.extract_type_from_enum_def(type_decl_node)
         elif type_decl_node['ast_type'] == 'StructDef':
             vy_type = CompilerLangVy.extract_type_from_struct_def(type_decl_node, self.consts)

certora_cli-8.5.1/certora_cli/CertoraProver/castingInstrumenter.py

@@ -0,0 +1,192 @@
+#     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 dataclasses import dataclass
+from typing import Dict, Any, Optional, Generator
+
+from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol
+from CertoraProver.certoraBuildDataClasses import SDC, Instrumentation, Replace
+from Shared import certoraUtils as Util
+
+
+@dataclass
+class IntType:
+    is_signed: bool
+    bitwidth: int
+
+    def encode(self) -> Optional[int]:
+        """
+        Encodes into a 9 bit number: lowest bit is on if [IntType] is true, and upper 8 bits are the width.
+        returns none if width is out of bounds.
+        """
+        if self.bitwidth <= 0 or self.bitwidth > 256:
+            return None
+        return self.bitwidth * 2 + int(self.is_signed)
+
+
+def parse_int_type(type_string: str) -> Optional[IntType]:
+    """
+    Parse an integer type string of the form 'int<bitwidth>' or 'uint<bitwidth>'.
+    Returns IntType or None if the string doesn't match the pattern.
+    """
+    if type_string == "int":
+        return IntType(True, 256)
+    elif type_string == "uint":
+        return IntType(False, 256)
+    elif type_string.startswith("int"):
+        is_signed = True
+        bitwidth_str = type_string[3:]
+    elif type_string.startswith("uint"):
+        is_signed = False
+        bitwidth_str = type_string[4:]
+    else:
+        return None
+
+    try:
+        bitwidth = int(bitwidth_str)
+        return IntType(is_signed, bitwidth)
+    except ValueError:
+        return None
+
+
+def is_int_type(type_string: str) -> bool:
+    return parse_int_type(type_string) is not None
+
+
+def encode_type(type_string: str) -> int:
+    int_type = parse_int_type(type_string)
+    if int_type is None:
+        raise Exception(f"Invalid type string: {type_string}")
+    encoded = int_type.encode()
+    if encoded is None:
+        raise Exception(f"Invalid type string: {type_string}")
+    return encoded
+
+
+@dataclass
+class CastInfo:
+    arg_type_str: str
+    res_type_str: str
+    expr_id: int
+
+
+def find_casts(ast: Dict[int, Any]) -> list[CastInfo]:
+    """
+    Search all nodes that are in functions for kind "typeConversion" with one argument.
+    Returns a list of CastInfo instances.
+    """
+    conversions = []
+    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):
+            if isinstance(node, dict) and node.get("kind") == "typeConversion":
+                arguments = node.get("arguments", [])
+                if len(arguments) == 1 and isinstance(arguments[0], dict):
+                    expression = node["expression"]
+                    expr_node_id = expression["id"]
+                    arg_type_str = expression["argumentTypes"][0]["typeString"]
+                    if not is_int_type(arg_type_str):
+                        continue
+                    if "typeName" not in expression:
+                        continue
+                    expr_type_node = expression["typeName"]
+                    if isinstance(expr_type_node, str):
+                        expr_type_str = expr_type_node
+                    else:
+                        expr_type_str = expr_type_node["name"]
+                    if not is_int_type(expr_type_str):
+                        continue
+                    conversions.append(CastInfo(arg_type_str, expr_type_str, expr_node_id))
+
+    return conversions
+
+
+def casting_func_name(counter: int) -> str:
+    return f"cast_{counter}"
+
+
+def generate_casting_function(assembly_prefix: str, cast_info: CastInfo, counter: 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)' + "}"
+    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) \
+        -> tuple[Dict[str, Dict[int, Instrumentation]], Dict[str, tuple[str, list[str]]]]:
+    """
+    Generate instrumentation for integer type casts in Solidity code.
+
+    Returns a tuple of:
+    - casting_instrumentation: Maps file paths to offset->Instrumentation mappings that replace type names with
+      library calls to casting functions we generate.
+    - casting_types: Maps file paths to library_name and the text for our new casting functions. This library is added
+      to the end of the file.
+
+    It's not hundred precent sure this works well in combination with `compiler_map`, because the counter for library
+    names may reset?
+    """
+    casting_instrumentation: Dict[str, Dict[int, Instrumentation]] = 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()
+
+    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):
+        main_ast = asts[contract_file]
+        curr_file_ast = main_ast.get(solfile, dict())
+
+        per_file_inst = casting_instrumentation.setdefault(solfile, dict())
+        libname, per_file_casts = casting_funcs.setdefault(solfile, (f"CertoraCastingLib{file_count}", []))
+
+        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(":")
+            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)
+            per_file_casts.append(new_func)
+
+    return casting_instrumentation, casting_funcs
+
+
+def iter_all_nodes(node: Any) -> Generator[Any, Optional[Any], None]:
+    """
+    Yield a node and all its subnodes in depth-first order.
+    Works with dict nodes that may contain nested dicts and lists.
+    """
+    yield node
+
+    if isinstance(node, dict):
+        for value in node.values():
+            if isinstance(value, (dict, list)):
+                yield from iter_all_nodes(value)
+    elif isinstance(node, list):
+        for item in node:
+            if isinstance(item, (dict, list)):
+                yield from iter_all_nodes(item)

{certora_cli-8.3.1 → certora_cli-8.5.1}/certora_cli/CertoraProver/certoraBuild.py

@@ -20,24 +20,24 @@ import os
 import re
 import shutil
 import sys
+import tempfile
 import typing
 from collections import OrderedDict, defaultdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from Crypto.Hash import keccak
-import tempfile
-
 from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
 
+from Crypto.Hash import keccak
 
+from CertoraProver.castingInstrumenter import generate_casting_instrumentation
 from CertoraProver.certoraBuildCacheManager import CertoraBuildCacheManager, CachedFiles
 from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference, ContractExtension, ContractInSDC, SDC, \
     Instrumentation, InsertBefore, InsertAfter, UnspecializedSourceFinder, instrumentation_logger
 from CertoraProver.certoraCompilerParameters import SolcParameters
+from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes, VyperMetadata
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
-from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
@@ -1381,11 +1381,17 @@ class CertoraBuildGenerator:
 
         return bytecode
 
-    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
-        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_via_ir')
-        assert isinstance(match, (bool, type(None))), f"Expected solc_via_ir to be bool or None, got {type(match)}"
+    def get_map_bool_attribute_value(self, contract_file_path: Path, attr_name: str) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, attr_name)
+        assert isinstance(match, (bool, type(None))), f"Expected {attr_name} to be bool or None, got {type(match)}"
         return bool(match)
 
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'solc_via_ir')
+
+    def get_vyper_venom_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'vyper_venom')
+
     def get_solc_evm_version_value(self, contract_file_path: Path) -> Optional[str]:
         match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_evm_version')
         assert isinstance(match, (str, type(None))), f"Expected solc_evm_version to be string or None, got {type(match)}"
@@ -1398,6 +1404,10 @@ class CertoraBuildGenerator:
             match = str(match)
         return match
 
+    def _handle_venom(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_vyper_venom_value(contract_file_path):
+            settings_dict["experimentalCodegen"] = True
+
     def _handle_via_ir(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
         if self.get_solc_via_ir_value(contract_file_path):
             settings_dict["viaIR"] = True
@@ -1510,6 +1520,9 @@ class CertoraBuildGenerator:
         self._handle_via_ir(contract_file_path, settings_dict)
         self._handle_evm_version(contract_file_path, settings_dict)
         self._handle_optimize(contract_file_path, settings_dict, compiler_collector)
+        compiler_lang = compiler_collector.smart_contract_lang
+        if compiler_lang == CompilerLangVy():
+            self._handle_venom(contract_file_path, settings_dict)
 
     @staticmethod
     def solc_setting_optimizer_runs(settings_dict: Dict[str, Any]) -> Tuple[bool, Optional[int]]:
@@ -1543,7 +1556,8 @@ class CertoraBuildGenerator:
                       contract_file_posix_abs: Path,
                       contract_file_as_provided: str,
                       remappings: List[str],
-                      compiler_collector: CompilerCollector) -> Dict[str, Any]:
+                      compiler_collector: CompilerCollector,
+                      compile_wd: Path) -> Dict[str, Any]:
         """
         when calling solc with the standard_json api, instead of passing it flags, we pass it json to request what we
         want -- currently we only use this to retrieve storage layout as this is the only way to do that,
@@ -1554,9 +1568,10 @@ class CertoraBuildGenerator:
         @param compiler_collector: Solidity or Vyper compiler collector
         @return:
         """
+        solc_json_contract_key = os.path.relpath(contract_file_as_provided, compile_wd) if self.context.use_relpaths_for_solc_json else contract_file_posix_abs
         compiler_collector_lang = compiler_collector.smart_contract_lang
         if compiler_collector_lang == CompilerLangSol() or compiler_collector_lang == CompilerLangYul():
-            sources_dict = {str(contract_file_posix_abs): {
+            sources_dict = {str(solc_json_contract_key): {
                 "urls": [str(contract_file_posix_abs)]}}  # type: Dict[str, Dict[str, Any]]
             output_selection = ["transientStorageLayout", "storageLayout", "abi", "evm.bytecode",
                                 "evm.deployedBytecode", "evm.methodIdentifiers", "evm.assembly",
@@ -1567,6 +1582,8 @@ class CertoraBuildGenerator:
                 contents = f.read()
                 sources_dict = {str(contract_file_posix_abs): {"content": contents}}
                 output_selection = ["abi", "evm.bytecode", "evm.deployedBytecode", "evm.methodIdentifiers"]
+                if compiler_collector.compiler_version >= (0, 4, 4):
+                    output_selection += ["metadata", "evm.deployedBytecode.symbolMap"]
                 ast_selection = ["ast"]
 
         settings_dict: Dict[str, Any] = \
@@ -1853,7 +1870,7 @@ class CertoraBuildGenerator:
         # Standard JSON
         remappings = [] if isinstance(compiler_collector, CompilerCollectorYul) else self.context.remappings
         input_for_solc = self.standard_json(Path(file_abs_path), build_arg_contract_file, remappings,
-                                            compiler_collector)
+                                            compiler_collector, compile_wd)
         standard_json_input = json.dumps(input_for_solc).encode("utf-8")
         compiler_logger.debug(f"about to run in {compile_wd} the command: {collect_cmd}")
         compiler_logger.debug(f"solc input = {json.dumps(input_for_solc, indent=4)}")
@@ -1909,7 +1926,7 @@ class CertoraBuildGenerator:
             contract_file_abs = str(Util.abs_norm_path(contract_file))
 
             # using os.path.relpath because Path.relative_to cannot go up the directory tree (no ..)
-            contract_file_rel = os.path.relpath(Path(contract_file_abs), Path.cwd())
+            contract_file_rel = os.path.relpath(Path(contract_file_abs), compile_wd)
 
             build_logger.debug(f"available keys: {data['contracts'].keys()}")
             if contract_file_rel in data[CONTRACTS]:
@@ -2008,7 +2025,15 @@ class CertoraBuildGenerator:
             srclist = {"0": file_abs_path}
             report_srclist = {"0": file_abs_path}
 
-        report_source_file = report_srclist[[idx for idx in srclist if srclist[idx] == file_abs_path][0]]
+        # Annoyingly, this is currently used just for... presentation?!
+        # We should clean up report_source_file from all places...
+
+        build_logger.debug(f"Finding report source file, abs path {file_abs_path} relative to {compile_wd}")
+        if self.context.use_relpaths_for_solc_json:
+            orig_report_source_file = Util.abs_posix_path(os.path.relpath(file_abs_path, compile_wd))
+        else:
+            orig_report_source_file = file_abs_path
+        report_source_file = report_srclist[[idx for idx in srclist if Util.abs_posix_path(srclist[idx]) == orig_report_source_file][0]]
 
         # all "contracts in SDC" are the same for every primary contract of the compiled file.
         # we can therefore compute those just once...
@@ -2039,8 +2064,9 @@ class CertoraBuildGenerator:
 
             build_logger.debug(f"finding primary contract address of {file_compiler_path}:{primary_contract} in "
                                f"{contracts_with_chosen_addresses}")
+            path_to_find = os.path.relpath(file_compiler_path, compile_wd) if self.context.use_relpaths_for_solc_json else file_compiler_path
             primary_contract_address = \
-                self.find_contract_address_str(file_compiler_path,
+                self.find_contract_address_str(path_to_find,
                                                primary_contract,
                                                contracts_with_chosen_addresses)
             build_logger.debug(f"Contracts in SDC {sdc_name}: {[contract.name for contract in contracts_in_sdc]}")
@@ -2086,7 +2112,7 @@ class CertoraBuildGenerator:
                 if new_path is None:
                     file_abs_path = Util.abs_posix_path(build_arg_contract_file)
                     # for vyper, because there are no autofinders, at least find the main file
-                    if (orig_file == file_abs_path and
+                    if (Util.abs_posix_path(orig_file) == file_abs_path and
                         ((Util.get_certora_sources_dir() / build_arg_contract_file).exists() or
                          Path(build_arg_contract_file).exists())):
                         new_srclist_map[idx] = build_arg_contract_file
@@ -2101,6 +2127,7 @@ class CertoraBuildGenerator:
                 report_srclist = srclist
         else:
             report_srclist = srclist
+        build_logger.debug(f"Report source list={report_srclist}")
         return report_srclist
 
     def get_bytecode(self,
@@ -2108,7 +2135,7 @@ class CertoraBuildGenerator:
                      contract_name: str,
                      primary_contracts: List[str],
                      contracts_with_chosen_addresses: List[Tuple[int, Any]],
-                     fail_if_no_bytecode: bool
+                     is_deployed_bytecode: bool
                      ) -> str:
         """
         Computes the linked bytecode object from the Solidity compiler output.
@@ -2119,20 +2146,31 @@ class CertoraBuildGenerator:
         @param primary_contracts - the names of the primary contracts we check to have a bytecode
         @param contracts_with_chosen_addresses - a list of tuples of addresses and the
             associated contract identifier
-        @param fail_if_no_bytecode - true if the function should fail if bytecode object is missing,
+        @param is_deployed_bytecode - true if we deal with deployed (runtime) bytecode,
+            thus the function should fail if bytecode object is missing,
             false otherwise
         @returns linked bytecode object
         """
         # TODO: Only contract_name should be necessary. This requires a lot more test cases to make sure we're not
         # missing any weird solidity outputs.
         bytecode_ = bytecode_object["object"]
-        bytecode = self.collect_and_link_bytecode(contract_name, contracts_with_chosen_addresses,
-                                                  bytecode_, bytecode_object.get("linkReferences", {}))
+        try:
+            bytecode = self.collect_and_link_bytecode(contract_name, contracts_with_chosen_addresses,
+                                                      bytecode_, bytecode_object.get("linkReferences", {}))
+        except Util.CertoraUserInputError as e:
+            if is_deployed_bytecode:
+                raise e
+            else:
+                prefix_msg = f"Failed to find a dependency library while building the "\
+                             f"constructor bytecode of {contract_name}. "\
+                             f"If you need the contract, import the missing library directly and add a dummy usage:\n"
+                orig_msg = str(e)
+                raise Util.CertoraUserInputError(prefix_msg + orig_msg)
         if contract_name in primary_contracts and len(bytecode) == 0:
             msg = f"Contract {contract_name} has no bytecode. " \
                   f"It may be caused because the contract is abstract, " \
                   f"or is missing constructor code. Please check the output of the Solidity compiler."
-            if fail_if_no_bytecode:
+            if is_deployed_bytecode:
                 raise Util.CertoraUserInputError(msg)
             else:
                 build_logger.warning(msg)
@@ -2202,6 +2240,40 @@ class CertoraBuildGenerator:
             storage_slot['descriptor'] = type_descriptor.as_dict()
         return storage_data
 
+    @staticmethod
+    def add_vyper_internal_function_data(internal_funcs: Set[Func], contract_data: Dict[str, Any]) -> None:
+        metadata = contract_data["metadata"]
+        symbol_map = contract_data["evm"]["deployedBytecode"]["symbolMap"]
+
+        for internal_func in internal_funcs:
+            # find metadata entry
+            func_name = internal_func.name
+            func_info = metadata['function_info']
+            metadata_func_info = None
+            for value in func_info.values():
+                if value.get("name") == func_name:
+                    metadata_func_info = value
+                    break
+            assert metadata_func_info is not None, f"Could not find metadata for internal function {func_name}"
+            vyper_metadata = VyperMetadata()
+            if metadata_func_info.get('frame_info'):
+                vyper_metadata.frame_size = metadata_func_info['frame_info']['frame_size']
+                vyper_metadata.frame_start = metadata_func_info['frame_info']['frame_start']
+            if metadata_func_info.get('venom_via_stack'):
+                vyper_metadata.venom_via_stack = metadata_func_info['venom_via_stack']
+            if metadata_func_info.get('venom_return_via_stack'):
+                vyper_metadata.venom_return_via_stack = metadata_func_info['venom_return_via_stack']
+            pattern_in_symbol_map = re.compile(fr"{func_name}\(.*\)_runtime$")
+            matches = [k for k in symbol_map if pattern_in_symbol_map.search(k)]
+            if len(matches) == 0:
+                build_logger.warning(f"Could not find symbol map entry for {func_name} probably was inlined")
+                continue
+            elif len(matches) > 1:
+                raise RuntimeError(f"Found multiple matches for {func_name} in symbol map: {matches}")
+            else:
+                vyper_metadata.runtime_start_pc = symbol_map[matches[0]]
+            internal_func.vyper_metadata = vyper_metadata
+
     def get_contract_in_sdc(self,
                             source_code_file: str,
                             contract_name: str,
@@ -2326,6 +2398,9 @@ class CertoraBuildGenerator:
         else:
             compiler_parameters = None
 
+        if compiler_lang == CompilerLangVy() and compiler_collector_for_contract_file.compiler_version >= (0, 4, 4):
+            self.add_vyper_internal_function_data(internal_funcs, contract_data)
+
         return ContractInSDC(contract_name,
                              # somehow make sure this is an absolute path which obeys the autofinder remappings
                              # (i.e. make sure this file doesn't start with autoFinder_)
@@ -2842,6 +2917,8 @@ class CertoraBuildGenerator:
 
                 self.SDCs[self.get_sdc_key(sdc.primary_contract, sdc.primary_contract_address)] = sdc
 
+        if self.context.dump_asts:
+            self.dump_asts()
         self.handle_links()
         self.handle_struct_links()
         self.handle_contract_extensions()
@@ -3002,7 +3079,7 @@ class CertoraBuildGenerator:
             target_file = self.context.contract_to_file[target.name]
             base_contracts = self.retrieve_base_contracts_list(
                 target_file,
-                Util.abs_posix_path(target_file),
+                target_file if self.context.use_relpaths_for_solc_json else Util.abs_posix_path(target_file),
                 target.name
             )
             extensions: Set[str] = set()
@@ -3078,8 +3155,9 @@ class CertoraBuildGenerator:
 
             # let's try to find the AST now
             build_file_ast = None
+            orig_path = os.path.relpath(ext_instance.original_file, Path.cwd()) if self.context.use_relpaths_for_solc_json else ext_instance.original_file
             for (k, v) in self.asts.items():
-                if ext_instance.original_file in v:
+                if orig_path in v:
                     build_file_ast = k
                     break
             if build_file_ast is None:
@@ -3087,10 +3165,10 @@ class CertoraBuildGenerator:
 
             contract_def_node = self.get_contract_def_node_ref(
                 build_file_ast,
-                ext_instance.original_file,
+                orig_path,
                 storage_ext
             )
-            def_node = self.asts[build_file_ast][ext_instance.original_file][contract_def_node]
+            def_node = self.asts[build_file_ast][orig_path][contract_def_node]
             nodes = def_node.get("nodes")
             if not isinstance(nodes, list):
                 raise RuntimeError(f"Couldn't find nodes for body of {storage_ext}")
@@ -3261,6 +3339,16 @@ class CertoraBuildGenerator:
         else:
             added_source_finders = {}
 
+        if self.context.safe_casting_builtin:
+            try:
+                casting_instrumentations, casting_types = generate_casting_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder)
+            except Exception as e:
+                instrumentation_logger.warning(
+                    f"Computing casting instrumentation failed for {build_arg_contract_file}: {e}", exc_info=True)
+                casting_instrumentations, casting_types = {}, {}
+
+            instr = CertoraBuildGenerator.merge_dicts_instrumentation(instr, casting_instrumentations)
+
         abs_build_arg_contract_file = Util.abs_posix_path(build_arg_contract_file)
         if abs_build_arg_contract_file not in instr:
             instrumentation_logger.debug(
@@ -3314,6 +3402,14 @@ class CertoraBuildGenerator:
                         read_so_far += amt + 1 + to_skip
                     output.write(in_file.read(-1))
 
+                    if self.context.safe_casting_builtin:
+                        library_name, funcs = casting_types.get(contract_file, ("", list()))
+                        if len(funcs) > 0:
+                            output.write(bytes(f"\nlibrary {library_name}" + "{\n", "utf8"))
+                            for f in funcs:
+                                output.write(bytes(f, "utf8"))
+                            output.write(bytes("}\n", "utf8"))
+
         new_file = self.to_autofinder_file(build_arg_contract_file)
         self.context.file_to_contract[new_file] = self.context.file_to_contract[
             build_arg_contract_file]
@@ -3789,6 +3885,16 @@ class CertoraBuildGenerator:
             # Avoiding Python interpreter shutdown exceptions which are safe to ignore
             pass
 
+    def dump_asts(self) -> None:
+        asts_dump_file = Util.get_asts_file()
+        filtered_asts = {k: v for k, v in self.asts.items() if not str(k).startswith(f"{Util.get_build_dir()}")}
+        with asts_dump_file.open("w+") as output_file:
+            try:
+                json.dump(filtered_asts, output_file, indent=4, sort_keys=True)
+            except Exception as e:
+                ast_logger.debug(f"Couldn't dump ASTs to {asts_dump_file}", exc_info=e)
+                raise
+
 
 # make sure each source file exists and its path is in absolute format
 def sources_to_abs(sources: Set[Path]) -> Set[Path]:

{certora_cli-8.3.1 → certora_cli-8.5.1}/certora_cli/CertoraProver/certoraBuildCacheManager.py

@@ -179,9 +179,12 @@ class CertoraBuildCacheManager:
             trg = trg_path_with_additional_included_files / post_autofinder_dir.name
             if post_autofinder_dir != trg:
                 if post_autofinder_dir.is_dir():
-                    if trg.exists():
-                        shutil.rmtree(trg)
-                    Util.safe_copy_folder(post_autofinder_dir, trg, shutil.ignore_patterns())
+                    # if we match on the cache, and we run a few certoraRun-s in parallel,
+                    # it could be this folder already exists. But the exact contents do not matter and are likely to
+                    # agree with the exception of spec files. So let's merge the folders so that the
+                    # sources are in any case runnable
+                    if not trg.exists():
+                        Util.safe_merge_folder(post_autofinder_dir, trg, shutil.ignore_patterns())
                 else:
                     # highly unlikely .post_autofinder.[digit] will be a file and not a directory,
                     # but would rather not crash and future-proof instead

{certora_cli-8.3.1 → certora_cli-8.5.1}/certora_cli/CertoraProver/certoraBuildDataClasses.py

@@ -189,6 +189,7 @@ class ContractInSDC:
             # why are we using this and not the normal list of functions?
             "internalFunctions": {key: method.as_dict() for key, method in self.function_finders.items()},
             # this doesn't even have all functions
+            "internalFuncs": [f.as_dict() for f in self.internal_funcs],
             "allMethods": [f.as_dict() for f in self.all_funcs],
             "solidityTypes": [x.as_dict() for x in self.types],
             "compilerName": "" if not self.compiler_collector else self.compiler_collector.compiler_name,

{certora_cli-8.3.1 → certora_cli-8.5.1}/certora_cli/CertoraProver/certoraCloudIO.py

@@ -689,8 +689,11 @@ class CloudVerification:
             auth_data["mutationTestId"] = self.context.mutation_test_id
         return auth_data
 
+    def get_group_id_url(self) -> str:
+        return f"{self.get_domain()}/?groupIds={self.context.group_id}"
+
     def print_group_id_url(self) -> None:
-        group_id_url = f"{self.get_domain()}/?groupIds={self.context.group_id}"
+        group_id_url = self.get_group_id_url()
         print(f"See all jobs generated from splitting the rules at {group_id_url}", flush=True)
 
     def print_output_links(self) -> None: