certora-cli 7.14.3__tar.gz → 7.17.2__tar.gz

{certora_cli-7.14.3/certora_cli.egg-info → certora_cli-7.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certora-cli
-Version: 7.14.3
+Version: 7.17.2
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -21,4 +21,4 @@ Requires-Dist: tabulate
 Requires-Dist: tqdm
 Requires-Dist: StrEnum
 
-Commit 59b7da5.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 501a551.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-7.17.2/README.md

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

{certora_cli-7.14.3 → certora_cli-7.17.2}/certora_cli/EVMVerifier/certoraBuild.py

@@ -7,6 +7,7 @@ import shutil
 import sys
 import typing
 from collections import OrderedDict
+from dataclasses import dataclass
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -50,6 +51,8 @@ OUTPUTS = "outputs"
 FUNCTION = "function"
 CONTRACTS = "contracts"
 NAME = "name"
+MANUAL_MUTANTS = "manual_mutants"
+MUTANTS_LOCATION = "mutants_location"
 
 FunctionSig = Tuple[str, List[str], List[str], str]
 
@@ -238,6 +241,18 @@ class PresetImmutableReference(ImmutableReference):
         return repr(self.as_dict())
 
 
+@dataclass
+class ContractExtension:
+    extension: "ContractInSDC"
+    exclusion: List[str]
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "extension": self.extension.as_dict(),
+            "exclusion": self.exclusion
+        }
+
+
 # Python3.5 to which we maintain backward-compatibility due to CI's docker image, does not support @dataclass
 class ContractInSDC:
     def __init__(self, name: str, source_file: str, lang: str,
@@ -246,13 +261,15 @@ class ContractInSDC:
                  methods: Set[Func], bytecode: str,
                  constructor_bytecode: str,
                  srcmap: str, varmap: Any, constructor_srcmap: str,
-                 storageLayout: Any, immutables: List[ImmutableReference],
+                 storage_layout: Any, transient_storage_layout: Any,
+                 immutables: List[ImmutableReference],
                  function_finders: Dict[str, InternalFunc], internal_funcs: Set[Func], public_funcs: Set[Func],
                  all_funcs: List[Func],
                  types: List[CT.Type],
                  compiler_collector: Optional[CompilerCollector],
                  source_bytes: Optional[SourceBytes],
                  compiler_parameters: Optional[CompilerParameters],
+                 extension_contracts: List[ContractExtension]
                  ):
         self.name = name
         self.original_file = source_file
@@ -266,7 +283,8 @@ class ContractInSDC:
         self.srcmap = srcmap
         self.varmap = varmap
         self.constructorSrcmap = constructor_srcmap
-        self.storageLayout = storageLayout
+        self.storage_layout = storage_layout
+        self.transient_storage_layout = transient_storage_layout
         self.immutables = immutables
         # function finder: a mapping from external function ids to
         # the ids of the internal functions they are "finding" for us
@@ -301,6 +319,7 @@ class ContractInSDC:
         else:
             compiler_version = "unknown"
         self.compiler_version = compiler_version
+        self.extension_contracts = extension_contracts
 
     def as_dict(self) -> Dict[str, Any]:
         """
@@ -319,7 +338,8 @@ class ContractInSDC:
             "srcmap": self.srcmap,
             "varmap": self.varmap,
             "constructorSrcmap": self.constructorSrcmap,
-            "storageLayout": self.storageLayout,
+            "storageLayout": self.storage_layout,
+            "transientStorageLayout": self.transient_storage_layout,
             "immutables": list(map(lambda x: x.as_dict(), self.immutables)),
             # the function finder field
             # why are we using this and not the normal list of functions?
@@ -331,6 +351,7 @@ class ContractInSDC:
             "compilerVersion": self.compiler_version,
             "compilerParameters": None if not self.compiler_parameters else self.compiler_parameters.as_dict(),
             "sourceBytes": None if self.source_bytes is None else self.source_bytes.as_dict(),
+            "extensionContracts": [e.as_dict() for e in self.extension_contracts]
         }
 
     def as_printable_dict(self) -> Dict[str, Any]:
@@ -345,7 +366,8 @@ class ContractInSDC:
             "file": self.report_source_file,
             "address": self.address,
             "methods": list(map(lambda x: x.as_dict(), self.methods)),
-            "storageLayout": self.storageLayout,
+            "storageLayout": self.storage_layout,
+            "transientStorageLayout": self.transient_storage_layout,
             "immutables": list(map(lambda x: x.as_dict(), self.immutables)),
             "internalFunctions": {k: method.as_dict() for k, method in self.function_finders.items()}
         }
@@ -359,6 +381,9 @@ class ContractInSDC:
     def __repr__(self) -> str:
         return repr(self.as_printable_dict())
 
+    def add_extension(self, extension: ContractExtension) -> None:
+        self.extension_contracts.append(extension)
+
 
 class SDC:
     """
@@ -413,6 +438,7 @@ class SDC:
                 return contract
         return None
 
+
 # this function is Solidity specific.
 # todo: create certoraBuildUtilsSol.py file, where such solidity specific functions will be.
 def generate_finder_body(f: Func, internal_id: int, sym: int, compiler_collector: CompilerCollectorSol,
@@ -562,7 +588,7 @@ def reprint_ast_type(node: Dict[str, Any]) -> Optional[str]:
         if "length" in node:
             lnode = node["length"]
             if type(lnode) is not dict or "nodeType" not in lnode or lnode["nodeType"] != "Literal" or \
-               "value" not in lnode:
+                    "value" not in lnode:
                 return None
             len_str = lnode["value"]
         else:
@@ -573,7 +599,7 @@ def reprint_ast_type(node: Dict[str, Any]) -> Optional[str]:
             return None
         p_node = node["pathNode"]
         if type(p_node) is not dict or "nodeType" not in p_node or \
-           p_node["nodeType"] != "IdentifierPath" or "name" not in p_node:
+                p_node["nodeType"] != "IdentifierPath" or "name" not in p_node:
             return None
         return p_node["name"]
     else:
@@ -595,7 +621,7 @@ def get_modifier_param_type_name(ind: int, def_node: Dict[str, Any], f: Func) ->
         return fallback
     param_def_node = params[ind]
     if type(param_def_node) is not dict or param_def_node["nodeType"] != "VariableDeclaration" or \
-       "typeName" not in param_def_node:
+            "typeName" not in param_def_node:
         return fallback
     param_type_node = param_def_node["typeName"]
     if type(param_type_node) is not dict:
@@ -1429,6 +1455,10 @@ class CertoraBuildGenerator:
     @staticmethod
     def collect_storage_layout(data: Dict[str, Any]) -> Any:
         return data.get("storageLayout", None)
+    
+    @staticmethod
+    def collect_transient_storage_layout(data: Dict[str, Any]) -> Any:
+        return data.get('transientStorageLayout', None)
 
     # Cache info - on PackingTest there are 514 hits and 34 misses
     @lru_cache(maxsize=128)
@@ -1579,10 +1609,10 @@ class CertoraBuildGenerator:
                 settings_dict["optimizer"]['runs'] = int(self.context.solc_optimize)
             # if we are not disabling finder friendly optimizer specifically, enable it whenever viaIR is also enabled
             if not self.context.strict_solc_optimizer and (
-               self.context.solc_via_ir or self.context.solc_experimental_via_ir):
+                    self.context.solc_via_ir or self.context.solc_experimental_via_ir):
                 # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
                 # full inliner step removed
-                solc0_8_26 = "dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" + \
+                solc0_8_26_to_0_8_27 = "dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" + \
                              "IulcscCTUtx[scCTUt]TOntnfDIuljmul[jul]VcTOculjmul"
                 solc0_8_13_to_0_8_25 = "dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]T" + \
                                        "peulxa[rul]xa[r]cLgvifCTUca[r]LSsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
@@ -1626,9 +1656,9 @@ class CertoraBuildGenerator:
                     yul_optimizer_steps = solc0_8_12
                 elif minor == 8 and 13 <= patch <= 25:
                     yul_optimizer_steps = solc0_8_13_to_0_8_25
-                elif minor == 8 and patch == 26:
-                    yul_optimizer_steps = solc0_8_26
-                assert yul_optimizer_steps is not None
+                elif minor == 8 and 26 <= patch <= 27:
+                    yul_optimizer_steps = solc0_8_26_to_0_8_27
+                assert yul_optimizer_steps is not None, 'Yul Optimizer steps missing for requested Solidity version. Please contact Certora team.'
 
                 yul_optimizer_steps = standard_replacement(yul_optimizer_steps)
 
@@ -1708,7 +1738,7 @@ class CertoraBuildGenerator:
         if compiler_collector_lang == CompilerLangSol() or compiler_collector_lang == CompilerLangYul():
             sources_dict = {str(contract_file_posix_abs): {
                 "urls": [str(contract_file_posix_abs)]}}  # type: Dict[str, Dict[str, Any]]
-            output_selection = ["storageLayout", "abi", "evm.bytecode", "evm.deployedBytecode", "evm.methodIdentifiers",
+            output_selection = ["transientStorageLayout", "storageLayout", "abi", "evm.bytecode", "evm.deployedBytecode", "evm.methodIdentifiers",
                                 "evm.assembly"]
             ast_selection = ["id", "ast"]
         elif compiler_collector_lang == CompilerLangVy():
@@ -2277,6 +2307,69 @@ class CertoraBuildGenerator:
                 build_logger.warning(msg)
 
         return bytecode
+    
+    def annotate_storage(self, storage_data: Dict, build_arg_contract_file: str) -> Dict:
+        '''
+        Summary
+        -------
+        Annotates the storage data dictionary in-place with more information needed by the prover.
+
+        Parameters
+        ----------
+        storage_data : Dict
+            The dictionary holding the storage data.
+        
+        Returns
+        -------
+        Dict
+            A reference to the modified storage_data
+        '''
+        def annotate_type(desc: CT.Type, type_name: str, store_types: Dict[str, Any],
+                          slot: Any = None, offset: Any = None) -> None:
+            number_of_bytes = store_types[type_name]['numberOfBytes']
+            lower_bound = store_types[type_name].get('lowerBound')
+            upper_bound = store_types[type_name].get('upperBound')
+            annotations = [CT.StorageAnnotation(number_of_bytes, slot, offset, lower_bound,
+                                                upper_bound)]
+            desc.annotate(annotations)
+
+            if isinstance(desc, CT.StructType):
+                for desc_member in desc.members:
+                    for struct_member in store_types[type_name]['members']:
+                        if desc_member.name == struct_member['label']:
+                            annotate_type(desc_member.type, struct_member['type'], store_types,
+                                            struct_member['slot'], struct_member['offset'])
+            if isinstance(desc, CT.MappingType):
+                annotate_type(desc.domain, store_types[type_name]['key'], store_types)
+                annotate_type(desc.codomain, store_types[type_name]['value'], store_types)
+            if isinstance(desc, CT.ArrayType):
+                annotate_type(desc.elementType, store_types[type_name]['base'], store_types)
+
+        if storage_data is None or not isinstance(storage_data, dict) or 'storage' not in storage_data:
+            return storage_data
+        
+        declarations = storage_data['storage']
+        if not isinstance(declarations, list):
+            return storage_data
+        
+        for storage_slot in declarations:
+            if not isinstance(storage_slot, dict) or not isinstance(storage_slot.get('astId', None), int):
+                continue
+
+            ast_id = storage_slot['astId']
+            node = self.get_node_from_asts(self.asts, build_arg_contract_file, ast_id)
+            if not isinstance(node, dict) or 'typeName' not in node:
+                continue
+            
+            descriptor = CT.Type.from_type_name_node(
+                lambda ref: self.get_original_def_node(build_arg_contract_file, ref),
+                lambda ref: self.get_contract_file_of_non_autofinder(build_arg_contract_file, ref),
+                node['typeName']
+            )
+            type_descriptor = descriptor
+            annotate_type(descriptor, storage_slot['type'], storage_data['types'])
+            storage_slot['descriptor'] = type_descriptor.as_dict()
+        return storage_data
 
     def get_contract_in_sdc(self,
                             source_code_file: str,
@@ -2319,7 +2412,7 @@ class CertoraBuildGenerator:
                 overrides=x.overrides,
                 contractName=x.contractName,
                 ast_id=x.ast_id,
-                source_bytes= x.source_bytes,
+                source_bytes=x.source_bytes,
                 original_file=x.original_file,
                 body_location=x.body_location,
             ) for x in clfuncs]
@@ -2364,46 +2457,8 @@ class CertoraBuildGenerator:
             constructor_bytecode)
         address, is_static_address = \
             self.find_contract_address(source_code_file, contract_name, contracts_with_chosen_addresses)
-        storage_layout = \
-            self.collect_storage_layout(contract_data)
-        if storage_layout is not None and type(storage_layout) is dict and "storage" in storage_layout:
-            declarations = storage_layout["storage"]
-            if type(declarations) is list:
-                for storage_slot in declarations:
-                    if type(storage_slot) is dict and type(storage_slot.get("astId", None)) is int:
-                        ast_id = storage_slot["astId"]  # type: int
-                        node = self.get_node_from_asts(self.asts, build_arg_contract_file, ast_id)
-                        if type(node) is dict and "typeName" in node:
-                            descriptor = CT.Type.from_type_name_node(
-                                lambda ref: self.get_original_def_node(build_arg_contract_file, ref),
-                                lambda ref: self.get_contract_file_of_non_autofinder(build_arg_contract_file, ref),
-                                node["typeName"]
-                            )
-                            type_descriptor = descriptor
-
-                            def annotate_type(desc: CT.Type, type_name: str, store_types: Dict[str, Any],
-                                              slot: Any = None, offset: Any = None) -> None:
-                                number_of_bytes = store_types[type_name]["numberOfBytes"]
-                                lower_bound = store_types[type_name].get("lowerBound")
-                                upper_bound = store_types[type_name].get("upperBound")
-                                annotations = [CT.StorageAnnotation(number_of_bytes, slot, offset, lower_bound,
-                                                                    upper_bound)]
-                                desc.annotate(annotations)
-
-                                if isinstance(desc, CT.StructType):
-                                    for desc_member in desc.members:
-                                        for struct_member in store_types[type_name]["members"]:
-                                            if desc_member.name == struct_member["label"]:
-                                                annotate_type(desc_member.type, struct_member["type"], store_types,
-                                                              struct_member["slot"], struct_member["offset"])
-                                if isinstance(desc, CT.MappingType):
-                                    annotate_type(desc.domain, store_types[type_name]["key"], store_types)
-                                    annotate_type(desc.codomain, store_types[type_name]["value"], store_types)
-                                if isinstance(desc, CT.ArrayType):
-                                    annotate_type(desc.elementType, store_types[type_name]["base"], store_types)
-
-                            annotate_type(descriptor, storage_slot["type"], storage_layout["types"])
-                            storage_slot["descriptor"] = type_descriptor.as_dict()
+        storage_layout = self.annotate_storage(self.collect_storage_layout(contract_data), build_arg_contract_file)
+        transient_storage_layout = self.annotate_storage(self.collect_transient_storage_layout(contract_data), build_arg_contract_file)
         immutables = self.collect_immutables(contract_data, build_arg_contract_file, compiler_lang)
 
         if self.context.internal_funcs is not None:
@@ -2443,6 +2498,7 @@ class CertoraBuildGenerator:
                              varmap,
                              constructor_srcmap,
                              storage_layout,
+                             transient_storage_layout,
                              immutables,
                              function_finders,
                              internal_funcs=internal_funcs,
@@ -2452,6 +2508,7 @@ class CertoraBuildGenerator:
                              compiler_collector=compiler_collector_for_contract_file,
                              source_bytes=source_bytes,
                              compiler_parameters=compiler_parameters,
+                             extension_contracts=list()
                              )
 
     @staticmethod
@@ -2936,6 +2993,7 @@ class CertoraBuildGenerator:
 
         self.handle_links()
         self.handle_struct_links()
+        self.handle_contract_extensions()
 
     @staticmethod
     def get_cwd_rel_in_sources(sources: Set[Path]) -> Tuple[Path, Path]:
@@ -3250,6 +3308,25 @@ class CertoraBuildGenerator:
                                    f"in slot {resolved_src_slot}")
                 self.SDCs[source_to_update].state[resolved_src_slot] = dst_address
 
+    def handle_contract_extensions(self):
+        if not self.context.contract_extensions:
+            return
+
+        contracts_by_name = {c.name: c for c in self.get_primary_contracts_from_sdcs()}
+        for extended, extending in self.context.contract_extensions.items():
+            if extended not in contracts_by_name:
+                raise Util.CertoraUserInputError(f"Can't find extended contract {extended} for contract extension")
+            extended_contract = contracts_by_name[extended]
+            for ext in extending:
+                extension = ext["extension"]
+                if extension not in contracts_by_name.keys():
+                    raise Util.CertoraUserInputError(f"Can't find extending contract {extension} for contract extension")
+                extension_contract = contracts_by_name[extension]
+                for f in ext["exclude"]:
+                    if extension_contract.find_method(f) is None:
+                        raise Util.CertoraUserInputError(f"Can't find a method named {f} in contract {extension_contract.name}")
+                extended_contract.add_extension(ContractExtension(extension_contract, ext["exclude"]))
+
     def check_if_immutable_is_defined_in_ast(self, reference_to_replace_with_link: str, src_contract: str) -> None:
         """
         @param reference_to_replace_with_link: The immutable we could not find in immutable_references
@@ -3331,6 +3408,11 @@ class CertoraBuildGenerator:
     def get_matching_sdc_names_from_SDCs(self, contract: str) -> List[str]:
         return list(self.__get_matching_sdc_names_for_SDCs_iterator(contract))
 
+    def get_primary_contracts_from_sdcs(self) -> List[ContractInSDC]:
+        ret = [v.find_contract(v.primary_contract) for v in self.SDCs.values()]
+        assert all(c is not None for c in ret), "failed to find some primary contracts"
+        return ret
+
     class SlotResolution(Enum):
         SLOT_NO_STORAGE_LAYOUT = enum.auto()
         SLOT_INVALID_STORAGE_LAYOUT = enum.auto()
@@ -3349,8 +3431,8 @@ class CertoraBuildGenerator:
                           string - returns the slot number associated with slot_name as hex without preceding 0x (or 0X)
                           string - relevant slots found, in case more than 1 slot found.
         """
-        storage_layouts = [c.storageLayout for c in sdc.contracts if
-                           c.name == primary_contract and c.storageLayout is not None]
+        storage_layouts = [c.storage_layout for c in sdc.contracts if
+                           c.name == primary_contract and c.storage_layout is not None]
         if len(storage_layouts) != 1:
             build_logger.debug(f"Expected exactly one storage layout matching {primary_contract}, "
                                f"got {len(storage_layouts)}")
@@ -3454,6 +3536,42 @@ class CertoraBuildGenerator:
 
         return slot_number
 
+    @staticmethod
+    def get_manual_mutants_file(context: CertoraContext) -> Set[Path]:
+        """
+        Returns a set of mutant Solidity files based on the manual mutations specified in the context.
+        These files are added to .certora_sources.
+
+        certoraRun generally skips the mutations object therefore no exceptions are raised if mutant files
+        cannot be read due to bad syntax or any other error
+
+        :param context:
+        :return: list of mutants file
+        """
+
+        def get_sol_files(path: Path) -> Set[Path]:
+            sol_files: Set[Path] = set()
+
+            if path.is_file() and path.suffix == SOL:
+                sol_files.add(path)
+            elif path.is_dir():
+                for file_path in path.rglob(fr'*{SOL}'):
+                    sol_files.add(file_path)
+            return sol_files
+
+        result: Set[Path] = set()
+        try:
+            manual_mutations = context.mutations[MANUAL_MUTANTS]
+            for mutation in manual_mutations:
+                try:
+                    mutation_path = mutation[MUTANTS_LOCATION]
+                except Exception:
+                    continue
+                result |= get_sol_files(Path(mutation_path))
+        except Exception:
+            pass
+        return result
+
     # The sources that are collected for the .certora_sources directory are all the files that are provided as input
     # (i.e. they are not generated during the certora build process) that are needed for precise rerunning certoraRun.
     #
@@ -3499,6 +3617,7 @@ class CertoraBuildGenerator:
         if hasattr(context, CONF_FILE_ATTR):
             add_to_sources(Path(getattr(context, CONF_FILE_ATTR)))
 
+        sources |= CertoraBuildGenerator.get_manual_mutants_file(context)
         return sources
 
     def __del__(self) -> None:
@@ -3633,6 +3752,7 @@ def build_from_cache_or_scratch(context: CertoraContext,
 
     return cache_hit, True, cached_files
 
+
 def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> None:
     """
     This is the main function of certoraBuild

{certora_cli-7.14.3 → certora_cli-7.17.2}/certora_cli/EVMVerifier/certoraConfigIO.py

@@ -38,6 +38,7 @@ def current_conf_to_file(context: CertoraContext) -> Dict[str, Any]:
     all_conf_names = Attrs.get_attribute_class().all_conf_names()
     context_to_save = dict(sorted(context_to_save.items(), key=lambda x: all_conf_names.index(x[0])))
     context_to_save.pop('build_dir', None)  # build dir should not be saved, each run should define its own build_dir
+    context_to_save.pop('mutation_test_id', None)  # mutation_test_id should be recreated for every run
 
     out_file_path = Util.get_last_conf_file()
     run_logger.debug(f"Saving last configuration file to {out_file_path}")

{certora_cli-7.14.3 → certora_cli-7.17.2}/certora_cli/EVMVerifier/certoraContext.py

@@ -92,39 +92,9 @@ def collect_jar_args(context: CertoraContext) -> List[str]:
         for value in prover_args_values:
             return_list.extend(value.split())
 
-    # CERT-926: Because of the way that the type checker jar and the evm jar command line argument parser
-    # is implemented, you cannot have one commandline argument for both jars. As a result we need an argument
-    # for the type checker jar and for the evm jar that control whether the CVL type checking code
-    # will permit Solidity function calls in CVL quantifier bodies.  We prioritize the type checker jar
-    # argument "typechecker_args" in the conf files and if it contains the flag "-allowSolidityQuantifierCalls true"
-    # we append the prover argument version to the list of prover jar arguments.
-    type_checker_values = getattr(context, Attrs.EvmProverAttributes.TYPECHECKER_ARGS.get_conf_key(), None)
-    if type_checker_values:
-        for value in type_checker_values:
-            values = value.split()
-            if values[0] == '-allowSolidityQuantifierCalls' and values[1] == 'true':
-                return_list.extend(['-allowSolidityCallsInQuantifiers', 'true'])
     return return_list
 
 
-def get_typechecker_arguments(context: CertoraContext) -> List[str]:
-    """
-    Assembles a string of all the command-line options the typechecker cares about
-    @param context: The context
-    @return: A string with all the options in the format the typechecker understands.
-    """
-    args = []
-    if context.typechecker_args:
-        args += context.typechecker_args
-
-    relevant_attrs = filter(lambda arg: get_attr_value(context, arg),
-                            [Attrs.EvmProverAttributes.RULE, Attrs.EvmProverAttributes.EXCLUDE_RULE,
-                             Attrs.EvmProverAttributes.FOUNDRY_TESTS_MODE])
-    args += create_jar_flag_list(context, list(relevant_attrs))
-
-    return args
-
-
 def get_local_run_cmd(context: CertoraContext) -> str:
     """
     Assembles a jar command for local run
@@ -147,9 +117,6 @@ def get_local_run_cmd(context: CertoraContext) -> str:
         certora_root_dir = Util.get_certora_root_directory().as_posix()
         jar_path = f"{certora_root_dir}/{Util.EMV_JAR}"
 
-    if context.allow_solidity_calls_in_quantifiers:
-        run_args.extend(['-allowSolidityCallsInQuantifiers true'])
-
     """
     This flag prevents the focus from being stolen from the terminal when running the java process.
     Stealing the focus makes it seem like the program is not responsive to Ctrl+C.
@@ -519,7 +486,10 @@ def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[s
                     f"{'-typeCheck ' if with_typechecking else ''}" \
                     f"{' '.join(args)}"
 
-    exit_code = Util.run_jar_cmd(typecheck_cmd, False, custom_error_message="Failed to compile spec files:",
+    exit_code = Util.run_jar_cmd(typecheck_cmd, False,
+                                 custom_error_message="Failed to run Certora Prover locally. Please check the errors "
+                                                      "below for problems in the specifications (.spec files) or the "
+                                                      "prover_args defined in the .conf file.",
                                  logger_topic="type_check")
     if exit_code != 0:
         raise Util.CertoraUserInputError("CVL specification syntax and type check failed")
@@ -533,9 +503,9 @@ def run_local_spec_check(with_typechecking: bool, context: CertoraContext) -> No
 
     if context.disable_local_typechecking or Util.is_ci_or_git_action():
         return
-    args = get_typechecker_arguments(context)
+    args = collect_jar_args(context)
     if Util.is_java_installed():
         run_typechecker("Typechecker.jar", with_typechecking, args)
     else:
-        raise Util.CertoraUserInputError("Cannot run local checks because of missing a suitable java installtion. "
+        raise Util.CertoraUserInputError("Cannot run local checks because of missing a suitable java installation. "
                                          "To skip local checks run with the --disable_local_typechecking flag")

{certora_cli-7.14.3 → certora_cli-7.17.2}/certora_cli/EVMVerifier/certoraContextAttributes.py

@@ -269,6 +269,19 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
+    SOLC_EVM_VERSION_MAP = AttrUtil.AttributeDefinition(
+        attr_validation_func=Vf.validate_solc_evm_version_map,
+        arg_type=AttrUtil.AttrArgType.MAP,
+        help_msg='Map contracts to the appropriate EVM version',
+        default_desc="Uses the same Solidity EVM version for all contracts",
+        argparse_args={
+            'action': AttrUtil.UniqueStore,
+            'type': lambda value: Vf.parse_dict('solc_map', value)
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False
+    )
+
     SOLC_MAP = AttrUtil.AttributeDefinition(
         attr_validation_func=Vf.validate_solc_map,
         arg_type=AttrUtil.AttrArgType.MAP,
@@ -496,6 +509,37 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
+    CONTRACT_EXTENSIONS = AttrUtil.AttributeDefinition(
+        attr_validation_func=Vf.validate_contract_extension_attr,
+        help_msg="Dictionary of extension contracts. Format:\n"
+                 '{\n'
+                 '  "ExtendedContractA: [\n'
+                 '    {\n'
+                 '      "extension": "ExtenderA",\n'
+                 '      "exclude": [\n'
+                 '        "method1",\n'
+                 '        ...,\n'
+                 '        "methodN"\n'
+                 '      ]\n'
+                 '    },\n'
+                 '    {\n'
+                 '      ...\n'
+                 '    }\n'
+                 '  ],\n'
+                 '  "ExtendedContractB: [\n'
+                 '    ...\n'
+                 '  ],\n'
+                 '  ...\n'
+                 '}',
+        default_desc="",
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+        arg_type=AttrUtil.AttrArgType.MAP,
+        argparse_args={
+            'action': AttrUtil.UniqueStore
+        }
+    )
+
     PROTOTYPE = AttrUtil.AttributeDefinition(
         attr_validation_func=Vf.validate_prototype_attr,
         arg_type=AttrUtil.AttrArgType.LIST,
@@ -607,17 +651,6 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
-    TYPECHECKER_ARGS = AttrUtil.AttributeDefinition(
-        arg_type=AttrUtil.AttrArgType.LIST,
-        help_msg="Send flags directly to the CVL typechecker",
-        default_desc="",
-        argparse_args={
-            'nargs': AttrUtil.ONE_OR_MORE_OCCURRENCES,
-            'action': AttrUtil.APPEND
-        },
-        affects_build_cache_key=False,
-        disables_build_cache=False
-    )
     INTERNAL_FUNCS = AttrUtil.AttributeDefinition(
         attr_validation_func=Vf.validate_json_file,
         argparse_args={
@@ -767,8 +800,6 @@ class InternalUseAttributes(AttrUtil.Attributes):
     )
 
 
-
-
 class BackendAttributes(AttrUtil.Attributes):
 
     UNUSED_SUMMARY_HARD_FAIL = AttrUtil.AttributeDefinition(
@@ -1334,6 +1365,7 @@ class BackendAttributes(AttrUtil.Attributes):
 
     ALLOW_SOLIDITY_CALLS_IN_QUANTIFIERS = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        jar_flag='-allowSolidityQuantifierCalls',
         argparse_args={
             'action': AttrUtil.STORE_TRUE
         },
@@ -1403,7 +1435,7 @@ def set_attribute_class(cls: Type[AttrUtil.Attributes]) -> None:
 
 def detect_application_class(args: List[str]) -> Type[AttrUtil.Attributes]:
     evm_suffixes = ('.sol', '.vy', '.yul', '.tac', '.json')
-    wasm_suffixes = '.wat'
+    wasm_suffixes = ('.wat', '.wasm')
     solana_suffixes = ('.so', '.o')
 
     attributes_logger.debug("calling detect_application_class")