certora-cli-beta-mirror 7.31.0__py3-none-any.whl → 8.1.0__py3-none-any.whl

certora_cli/CertoraProver/certoraContextValidator.py

@@ -13,6 +13,7 @@
 #     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 logging
 import os
 import re
@@ -31,7 +32,7 @@ from CertoraProver.certoraContextClass import CertoraContext
 from Shared import certoraUtils as Util
 from Shared import certoraAttrUtil as AttrUtil
 from CertoraProver.certoraProjectScanner import scan_project
-
+import CertoraProver.certoraApp as App
 
 scripts_dir_path = Path(__file__).parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
@@ -45,10 +46,28 @@ class CertoraContextValidator:
     def __init__(self, context: CertoraContext):
         self.context = context
 
+    def handle_concord_attrs(self) -> None:
+        if self.context.app == App.ConcordApp:
+            for attr in (Attrs.ConcordAttributes.unsupported_attributes()):
+                attr_name = attr.get_conf_key()
+                if getattr(self.context, attr_name):
+                    if attr.arg_type == AttrUtil.AttrArgType.BOOLEAN:
+                        setattr(self.context, attr_name, False)
+                    else:
+                        setattr(self.context, attr_name, None)
+                    raise Util.CertoraUserInputError(f"Concord does not support {attr_name}")
+            if not self.context.check_method:
+                raise Util.CertoraUserInputError("'check_method' attribute/flag is mandatory when running Concord")
+            contracts = getattr(self.context, 'contracts', None)
+            if not contracts:
+                raise Util.CertoraUserInputError("No contracts were specified for Concord")
+            if len(contracts) != 2:
+                raise Util.CertoraUserInputError(f"expecting 2 contracts for Concord, got {len(contracts)}: {contracts}")
+
     def handle_ranger_attrs(self) -> None:
         # unset unsupported attributes
-        if Attrs.is_ranger_app():
-            for attr in Attrs.RangerAttributes.ranger_unsupported_attributes():
+        if self.context.app == App.RangerApp:
+            for attr in Attrs.RangerAttributes.unsupported_attributes():
                 attr_name = attr.get_conf_key()
                 if getattr(self.context, attr_name):
                     if attr.arg_type == AttrUtil.AttrArgType.BOOLEAN:
@@ -66,7 +85,7 @@ class CertoraContextValidator:
                                        f"ignoring the set value of {self.context.loop_iter}")
             self.context.loop_iter = self.context.loop_iter or Util.DEFAULT_RANGER_LOOP_ITER
 
-            for attr in Attrs.RangerAttributes.ranger_true_by_default_attributes():
+            for attr in Attrs.RangerAttributes.true_by_default_attributes():
                 attr_name = attr.get_conf_key()
                 setattr(self.context, attr_name, True)
 
@@ -80,7 +99,7 @@ class CertoraContextValidator:
 
     def validate(self) -> None:
 
-        for attr_def in Attrs.get_attribute_class().attribute_list():
+        for attr_def in self.context.app.attr_class.attribute_list():
             conf_key = attr_def.get_conf_key()
             attr = getattr(self.context, conf_key, None)
             if attr_def.deprecation_msg and attr:
@@ -141,9 +160,9 @@ class CertoraContextValidator:
 
         if value is None:
             raise RuntimeError(f"calling validate_type_string with null value {conf_key}")
-        if not isinstance(value, str):
-            raise Util.CertoraUserInputError(f"value of {conf_key} {value} is not a string")
-        attr.validate_value(value)
+        if not isinstance(value, (str, int)):
+            raise Util.CertoraUserInputError(f"value of {conf_key} {value} is not a string or an integer")
+        attr.validate_value(str(value))
 
     def validate_type_boolean(self, attr: AttrUtil.AttributeDefinition) -> None:
         conf_key, value = self.__get_key_and_value(attr)
@@ -164,6 +183,12 @@ class CertoraContextValidator:
             if len(context.files) > 1:
                 raise Util.CertoraUserInputError("Rust projects must specify exactly one executable in 'files'.")
 
+        if context.url_visibility and context.local:
+            validation_logger.info("'url_visibility' has no effect in local tool runs")
+        set_attr_default(context, attr_name=Attrs.CommonAttributes.URL_VISIBILITY.name.lower(),
+                         ci_value=str(Vf.UrlVisibilityOptions.PUBLIC),
+                         default_value=str(Vf.UrlVisibilityOptions.PRIVATE))
+
     def check_args_post_argparse(self) -> None:
         """
         Performs checks over the arguments after basic argparse parsing
@@ -201,7 +226,7 @@ class CertoraContextValidator:
         check_contract_name_arg_inputs(context)  # Here context.contracts is set
         Util.check_packages_arguments(context)
         convert_to_compiler_map(context)
-        if Attrs.is_evm_app():
+        if Ctx.is_evm_app_class(context):
             if context.compiler_map is None and context.bytecode_jsons is None:  # xxx - we would need to reiterate here
                 # once we allow combining raw bytecode with Solidity
                 context.solc = Vf.is_solc_file_valid(context.solc)
@@ -218,10 +243,18 @@ class CertoraContextValidator:
         if context.compilation_steps_only and context.build_only:
             raise Util.CertoraUserInputError("cannot use both 'compilation_steps_only' and 'build_only'")
 
-        set_wait_for_results_default(context)
+        set_attr_default(context, attr_name=Attrs.CommonAttributes.WAIT_FOR_RESULTS.name.lower(),
+                         ci_value=str(Vf.WaitForResultOptions.ALL),
+                         default_value=str(Vf.WaitForResultOptions.NONE))
         if context.wait_for_results and context.wait_for_results != str(Vf.WaitForResultOptions.NONE) and context.local:
             validation_logger.warning("'wait_for_results' has no effect in local tool runs")
 
+        if context.url_visibility and context.local:
+            validation_logger.info("'url_visibility' has no effect in local tool runs")
+        set_attr_default(context, attr_name=Attrs.CommonAttributes.URL_VISIBILITY.name.lower(),
+                         ci_value=str(Vf.UrlVisibilityOptions.PUBLIC),
+                         default_value=str(Vf.UrlVisibilityOptions.PRIVATE))
+
         # packages must be in a normal form (no unneeded . or ..)
         if context.packages:
             for idx, el in enumerate(context.packages):
@@ -427,14 +460,6 @@ def check_contract_name_arg_inputs(context: CertoraContext) -> None:
         check_conflicting_link_args(context)
 
     context.verified_contract_files = []
-    if context.assert_contracts is not None:
-        for assert_arg in context.assert_contracts:
-            contract = Util.get_trivial_contract_name(assert_arg)
-            if contract not in contract_names:
-                __suggest_contract_name(f"'assert' argument, {contract}, doesn't match any contract name", contract,
-                                        contract_names, contract_to_file)
-            else:
-                context.verified_contract_files.append(contract_to_file[contract])
 
     context.spec_file = None
 
@@ -448,7 +473,7 @@ def check_contract_name_arg_inputs(context: CertoraContext) -> None:
         context.spec_file = spec
 
     contract_to_address = dict()
-    if context.address:
+    if getattr(context, 'address', None):
         for address_str in context.address:
             contract = address_str.split(':')[0]
             if contract not in contract_names:
@@ -464,7 +489,7 @@ def check_contract_name_arg_inputs(context: CertoraContext) -> None:
                 all_warnings.add(f'address {number} for contract {contract} defined twice')
     context.address = contract_to_address
 
-    if context.struct_link:
+    if getattr(context, 'struct_link', None):
         contract_slot_to_contract = dict()
         for link in context.struct_link:
             location = link.split('=')[0]
@@ -580,31 +605,32 @@ def check_mode_of_operation(context: CertoraContext) -> None:
 
     @param context: A namespace including all CLI arguments provided
     @raise an CertoraUserInputError when:
-        1. .conf|.tac|.json file is used with --assert_contracts flags
-        2. when both --assert_contracts and --verify flags were given
-        3. when the file is not .tac|.conf|.json and neither --assert_contracts nor --verify were used
-        4. If either --bytecode_jsons or --bytecode_spec was used without the other.
+        1. when both --equivalence_contracts and --verify flags were given
+        2. when the file is not .tac|.conf|.json and neither --equivalence_contracts nor --verify were used
+        3. If either --bytecode_jsons or --bytecode_spec was used without the other.
     """
     context.is_verify = context.verify is not None and len(context.verify) > 0
-    context.is_assert = context.assert_contracts is not None and len(context.assert_contracts) > 0
     context.is_bytecode = context.bytecode_jsons is not None and len(context.bytecode_jsons) > 0
-    context.is_equivalence = context.equivalence_contracts is not None
+    context.is_equivalence = context.equivalence_contracts is not None or context.app == App.ConcordApp
 
-    if (context.project_sanity or context.foundry) and (context.is_verify or context.is_assert or context.is_bytecode or context.is_equivalence):
-        raise Util.CertoraUserInputError("The 'project_sanity' and 'foundry' options cannot coexist with the 'verify', 'assert_contract' or 'bytecode_jsons' options")
+    if (context.project_sanity or context.foundry) and \
+       (context.is_verify or context.is_bytecode or context.is_equivalence):
+        raise Util.CertoraUserInputError("The 'project_sanity' and 'foundry' options cannot coexist with the 'verify', "
+                                         "'assert_contract' or 'bytecode_jsons' options")
 
     if context.project_sanity and context.foundry:
         raise Util.CertoraUserInputError("The 'project_sanity' and 'foundry' options cannot coexist")
 
-    if len(list(filter(None, [context.is_verify, context.is_assert, context.is_equivalence]))) > 1:
-        raise Util.CertoraUserInputError("only one option of 'assert_contracts', 'verify', 'equivalence' can be used")
+    if len(list(filter(None, [context.is_verify, context.is_equivalence]))) > 1:
+        raise Util.CertoraUserInputError("only one option of 'verify', 'equivalence' can be used")
 
     has_bytecode_spec = context.bytecode_spec is not None
     if has_bytecode_spec != context.is_bytecode:
         raise Util.CertoraUserInputError("Must use 'bytecode' together with 'bytecode_spec'")
 
     if not context.files and not any((context.is_bytecode, context.project_sanity, context.foundry)):
-        raise Util.CertoraUserInputError("Should always provide input files, unless 'bytecode_jsons' or 'project_sanity' or 'foundry' are used")
+        raise Util.CertoraUserInputError("Should always provide input files, unless 'bytecode_jsons' or "
+                                         "'project_sanity' or 'foundry' are used")
 
     if context.is_bytecode and context.files:
         raise Util.CertoraUserInputError("Cannot use 'bytecode_jsons' with other files")
@@ -618,7 +644,8 @@ def check_mode_of_operation(context: CertoraContext) -> None:
         if not context.files:
             file_contract_pairs = _get_project_file_contract_pairs(context)
             main_contract = file_contract_pairs[0][1]  # any contract
-            context.files = [f"{file}:{contract}" if file.stem != contract else str(file) for file, contract in file_contract_pairs]
+            context.files = \
+                [f"{file}:{contract}" if file.stem != contract else str(file) for file, contract in file_contract_pairs]
         else:
             first = context.files[0]
             if ':' in first:
@@ -630,12 +657,14 @@ def check_mode_of_operation(context: CertoraContext) -> None:
 
         context.verify = f"{main_contract}:{spec_file_name}"
         context.is_verify = True
-        # In this mode we want to make life easy for the user, so use the auto-dispatcher mode to avoid many unresolved calls
+        # In this mode we want to make life easy for the user,
+        # so use the auto-dispatcher mode to avoid many unresolved calls
         context.auto_dispatcher = True
 
     if context.foundry:
         file_contract_pairs = _get_project_file_contract_pairs(context)
-        test_pairs = [(file, contract) for file, contract in file_contract_pairs if file.stem.endswith(".t") and 'lib' not in file.parents]
+        test_pairs = [(file, contract) for file, contract in file_contract_pairs
+                      if file.stem.endswith(".t") and 'lib' not in file.parents]
         context.files = [f"{file}:{contract}" for file, contract in test_pairs]
         main_contract = test_pairs[0][1]  # any contract
         spec_file_name = _generate_temp_spec(context, "use builtin rule verifyFoundryFuzzTestsNoRevert;\n")
@@ -643,7 +672,8 @@ def check_mode_of_operation(context: CertoraContext) -> None:
         context.foundry_tests_mode = True
         context.verify = f"{main_contract}:{spec_file_name}"
         context.is_verify = True
-        # In this mode we want to make life easy for the user, so use the auto-dispatcher mode to avoid many unresolved calls
+        # In this mode we want to make life easy for the user,
+        # so use the auto-dispatcher mode to avoid many unresolved calls
         context.auto_dispatcher = True
 
     if context.files:
@@ -656,16 +686,14 @@ def check_mode_of_operation(context: CertoraContext) -> None:
         for input_file in context.files:
             special_file_type = next((suffix for suffix in special_file_suffixes if input_file.endswith(suffix)), None)
 
-            if special_file_type:
-                if len(context.files) > 1:
-                    raise Util.CertoraUserInputError(
-                        f"No other files are allowed with a file of type {special_file_type}")
-                if context.is_assert:
-                    raise Util.CertoraUserInputError(
-                        f"Option 'assert_contracts' cannot be used with a {special_file_type} file {input_file}")
+            if special_file_type and len(context.files) > 1:
+                raise Util.CertoraUserInputError(
+                    f"No other files are allowed with a file of type {special_file_type}")
 
-    if not any([context.is_assert, context.is_verify, context.is_bytecode, context.equivalence_contracts,
-                special_file_type]) and not context.build_only:
+    if (
+        not context.app == App.ConcordApp and
+        not any([context.is_verify, context.is_bytecode,
+                 context.equivalence_contracts, special_file_type]) and not context.build_only):
         raise Util.CertoraUserInputError("You must use 'verify' when running the Certora Prover")
 
 def find_matching_contracts(context: CertoraContext, pattern: str) -> List[str]:
@@ -883,16 +911,17 @@ def check_files_input(file_list: List[str]) -> None:
             if file.endswith(Util.SOROBAN_EXEC_EXTENSION):
                 raise Util.CertoraUserInputError(f'The Soroban file {file} cannot be accompanied with other files')
 
-def set_wait_for_results_default(context: CertoraContext) -> None:
-    if context.wait_for_results is None:
+
+def set_attr_default(context: CertoraContext, attr_name: str, ci_value: str, default_value: str) -> None:
+    if getattr(context, attr_name, None) is None:
         if Util.is_ci_or_git_action():
-            context.wait_for_results = str(Vf.WaitForResultOptions.ALL)
+            setattr(context, attr_name, ci_value)
         else:
-            context.wait_for_results = str(Vf.WaitForResultOptions.NONE)
+            setattr(context, attr_name, default_value)
 
 
 def mode_has_spec_file(context: CertoraContext) -> bool:
-    return not context.is_assert and not context.is_tac and not context.is_equivalence
+    return not (context.is_tac or context.is_equivalence)
 
 
 def to_relative_paths(paths: Union[str, List[str]]) -> Union[str, List[str]]:

certora_cli/CertoraProver/certoraContractFuncs.py

@@ -57,14 +57,17 @@ class Func:
                  notpayable: bool,
                  fromLib: bool,  # actually serialized
                  isConstructor: bool,  # not serialized
+                 is_free_func: bool,
                  stateMutability: str,
                  visibility: str,
                  implemented: bool,  # does this function have a body? (false for interface functions)
                  overrides: bool,  # does this function override an interface declaration or super-contract definition?
+                 virtual: bool,
                  contractName: str,
                  source_bytes: Optional[SourceBytes],
                  ast_id: Optional[int],
                  original_file: Optional[str],
+                 location: Optional[str],
                  body_location: Optional[str],
                  ):
         self.name = name
@@ -75,13 +78,16 @@ class Func:
         self.notpayable = notpayable
         self.fromLib = fromLib
         self.isConstructor = isConstructor
+        self.is_free_func = is_free_func
         self.stateMutability = stateMutability
         self.visibility = visibility
         self.original_file = original_file
+        self.location = location
         self.body_location = body_location
         self.implemented = implemented
         self.ast_id = ast_id
         self.overrides = overrides
+        self.virtual = virtual
         self.contractName = contractName
         self.source_bytes = source_bytes
 

certora_cli/CertoraProver/certoraType.py

@@ -158,6 +158,15 @@ class Type(ABC):
             ast_logger.fatal(f"unexpected AST Type Name Node: {name}")
         return ret
 
+    def contains_mapping(self) -> bool:
+        if isinstance(self, MappingType):
+            return True
+        if isinstance(self, StructType):
+            return any(member.contains_mapping() for member in self.members)
+        if isinstance(self, ArrayType):
+            return self.elementType.contains_mapping()
+        return False
+
 
 class PrimitiveType(Type):
     allowed_primitive_type_names = {
@@ -204,7 +213,7 @@ class PrimitiveType(Type):
         return PrimitiveType.canonical_primitive_name(self.name)
 
     def get_source_str(self) -> str:
-        return self.name
+        return self.type_string  # this is different from `self.name` in the case of a payable address
 
 
 class StringType(Type):

certora_cli/CertoraProver/certoraVerifyGenerator.py

@@ -23,6 +23,7 @@ from typing import Dict, Any, Set, List, Tuple, Optional
 from CertoraProver.certoraMiniSpecParser import SpecImportLexer, SpecImportParser, SpecWithImports
 from CertoraProver.certoraContextClass import CertoraContext
 from Shared import certoraUtils as Util
+import CertoraProver.certoraApp as App
 
 build_logger = logging.getLogger("build_conf")
 
@@ -47,10 +48,6 @@ class CertoraVerifyGenerator:
             # we need to build once because of the early typechecking...
             self.update_certora_verify_struct(False)
 
-        elif self.context.assert_contracts is not None:
-            contract_to_check_asserts_for = self.context.assert_contracts
-            self.certora_verify_struct = {"type": "assertion",
-                                          "primaryContracts": contract_to_check_asserts_for}
         elif self.context.equivalence_contracts is not None:
             if self.context.method is None:
                 raise Util.CertoraUserInputError("Argument `method` is required for equivalence checks")
@@ -63,6 +60,15 @@ class CertoraVerifyGenerator:
                 "primary_contract": equiv_contracts[0],
                 "secondary_contract": equiv_contracts[1]
             }
+        elif context.app == App.ConcordApp:
+            if len(context.contracts) != 2:
+                raise Util.CertoraUserInputError(f"Expecting 2 contracts but got {len(context.contracts)}: {context.contracts}")
+            contract_list = list(context.contracts)
+            self.certora_verify_struct = {
+                "type": "equivalence",
+                "primary_contract": contract_list[0],
+                "secondary_contract": contract_list[1]
+            }
 
     def update_certora_verify_struct(self, in_certora_sources: bool) -> None:
         """

certora_cli/CertoraProver/splitRules.py

@@ -18,11 +18,14 @@ import sys
 import re
 from pathlib import Path
 import subprocess
+import tempfile
 import uuid
 
 from typing import List, Set, Optional
 
+import CertoraProver.certoraContext as Ctx
 import CertoraProver.certoraContextAttributes as Attrs
+import CertoraProver.certoraApp as App
 from CertoraProver.certoraContextClass import CertoraContext
 from Shared import certoraUtils as Util
 
@@ -71,33 +74,33 @@ class SplitRulesHandler():
         def jar_list_value(list_attr: List[str]) -> str:
             return ','.join(list_attr)
 
-        path_to_typechecker = Util.find_jar("Typechecker.jar")
+        with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
+            args = ["-listRules", tmp_file.name]
 
-        command = ["java", "-jar", str(path_to_typechecker), "-listRules", "-buildDirectory", str(Util.get_build_dir())]
+            if self.context.exclude_rule:
+                args += ['-excludeRule', jar_list_value(self.context.exclude_rule)]
 
-        if self.context.exclude_rule:
-            command += ['-excludeRule', jar_list_value(self.context.exclude_rule)]
+            if not split_rules and self.context.rule:
+                args += ['-rule',  jar_list_value(self.context.rule)]
+            elif split_rules and self.context.split_rules:
+                args += ['-rule', jar_list_value(self.context.split_rules)]
 
-        if not split_rules and self.context.rule:
-            command += ['-rule',  jar_list_value(self.context.rule)]
-        elif split_rules and self.context.split_rules:
-            command += ['-rule', jar_list_value(self.context.split_rules)]
-        try:
+            try:
+                Ctx.run_local_spec_check(False, self.context, args, print_errors=False)
+                lines = tmp_file.read().split("\n")
+                return set(lines)
 
-            result = subprocess.run(command, capture_output=True, text=True, check=True)
-            lines = result.stdout.strip().split("\n")
-            filtered_lines = [s for s in lines if not (s.startswith("Warning:") or " " in s)]
-            return set(filtered_lines)
-
-        except subprocess.CalledProcessError as e:
-            raise Util.CertoraUserInputError(f"Failed to get {'split ' if split_rules else ''}rules\ncommand: {command}\n{e}")
+            except Exception as e:
+                raise Util.CertoraUserInputError(f"Failed to get {'split ' if split_rules else ''}rules\n{e}")
 
     def run_commands(self) -> int:
         rule_flag = Attrs.EvmProverAttributes.RULE.get_flag()
         split_rules_flag = Attrs.EvmProverAttributes.SPLIT_RULES.get_flag()
         msg_flag = Attrs.CommonAttributes.MSG.get_flag()
+
         # it is important to use the cache, when the difference between the runs is only the rules that apply
         build_cache_flag = Attrs.EvmProverAttributes.BUILD_CACHE.get_flag()
+
         group_id_flag = Attrs.EvmProverAttributes.GROUP_ID.get_flag()
         disable_local_typechecking_flag = Attrs.EvmProverAttributes.DISABLE_LOCAL_TYPECHECKING.get_flag()
 
@@ -120,7 +123,7 @@ class SplitRulesHandler():
             if called as library then if running in local mode we use certoraRun.py otherwise certoraRun (from package)
             :return:
             """
-            assert Attrs.is_evm_app(), "Split rules is supported only for EVM apps"
+            assert self.context.app == App.EvmApp, "Split rules is supported only for EVM apps"
             if hasattr(self.context, 'prover_cmd'):
                 return self.context.prover_cmd
             if self.context.local:

certora_cli/CertoraProver/storageExtension.py

@@ -32,8 +32,6 @@ from CertoraProver.certoraBuildDataClasses import ContractInSDC
 from CertoraProver import erc7201
 from Shared import certoraUtils as Util
 from CertoraProver.certoraBuildDataClasses import SDC
-from CertoraProver.Compiler.CompilerCollectorFactory import get_relevant_compiler
-from CertoraProver.certoraContextClass import CertoraContext
 
 NameSpacedStorage: TypeAlias = Tuple[str, str]
 NewStorageFields = List[Dict[str, Any]]
@@ -351,36 +349,3 @@ def validate_new_fields(
         raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} is already mapped by {target_contract.name}")
     if var in target_vars:
         raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} is already declared by {target_contract.name}")
-
-
-def add_harness_to_compiler_map(original_file: str, harness_file: Any, context: CertoraContext) -> None:
-    """
-    Associates the generated harness file with the same compiler version as the original file.
-
-    This ensures the harness contract is compiled with the same Solidity compiler version
-    as the contract it's extending, maintaining compatibility.
-
-    Args:
-        original_file (str): Path to the original source file
-        harness_file (Any): File-like object representing the generated harness file
-        context (CertoraContext): The context object containing compiler mapping information
-
-    Returns:
-        None
-    """
-    # Validate prerequisites before updating compiler map
-    if context.compiler_map is None:
-        storage_extension_logger.debug("Cannot add compiler for harness: compiler_map is None (not a dict). Using the default compiler")
-        return
-
-    # Get the compiler version used for the original file
-    compiler_version = get_relevant_compiler(Path(original_file), context)
-
-    # Extract just the filename from the harness file path
-    harness_filename = Path(harness_file.name).name
-
-    # Add the compiler version to the context using glob pattern for the harness file
-    map_key = f"*{harness_filename}"
-    context.compiler_map[map_key] = compiler_version
-
-    storage_extension_logger.debug(f"Added compiler mapping: {map_key} -> {compiler_version}")

certora_cli/EquivalenceCheck/equivCheck.py

@@ -30,6 +30,7 @@ from CertoraProver.certoraBuild import InputConfig, CertoraBuildGenerator, Funct
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
 from CertoraProver.certoraContext import get_args
 from certoraRun import run_certora
+import CertoraProver.certoraApp as App
 
 LOG_PATH = Path('EqCheck_log.log')
 SANITY_PATH = Path('sanity.spec')
@@ -140,7 +141,7 @@ class EquivalenceChecker:
             tmp_conf = self.path / TMP_SANITY_CONF
             with tmp_conf.open('w') as temp_sanity:
                 json.dump(contents, temp_sanity, indent=4)
-            context = get_args([str(tmp_conf)])
+            context = get_args([str(tmp_conf)], App.EvmApp)
             config = InputConfig(context)
             cfb = CertoraBuildGenerator(config, context)
             certora_verify_generator = CertoraVerifyGenerator(context)

certora_cli/Mutate/mutateApp.py

@@ -28,7 +28,6 @@ from typing import Optional, Any, List, Dict, Tuple, Set, Union
 import logging
 from types import SimpleNamespace
 import tarfile
-import json5
 import csv
 import time
 import requests
@@ -54,6 +53,7 @@ from Mutate import mutateAttributes as MutAttrs
 import CertoraProver.certoraContextAttributes as Attrs
 from CertoraProver.certoraContextClass import CertoraContext
 from rustMutator import run_universal_mutator
+from CertoraProver import certoraContextValidator as Cv
 
 class RunTimedout(Exception):
     pass
@@ -710,6 +710,7 @@ class MutateApp:
     dump_csv: Optional[Path]
     sync: bool
     wait_for_original_run: bool
+    url_visibility: Vf.UrlVisibilityOptions
     collect_file: Optional[Path]
     poll_timeout: Optional[int]
     max_timeout_attempts_count: Optional[int]
@@ -722,7 +723,7 @@ class MutateApp:
     def __init__(self, args_list: List[str]) -> None:
         self.mutation_test_id = ''
         self.numb_of_jobs: int = 0
-        self.backup_paths: List[Path] = []
+        self.backup_path: Optional[Path] = None
         self.sources_dir: Optional[Path] = None
         self.with_split_stats_data = False
         self.manual_mutants_list: List[Mutant] = list()
@@ -881,9 +882,9 @@ class MutateApp:
                                                      " verification results. Please remove or replace the mutation")
 
     def restore_backups(self) -> None:
-        for backup_path in self.backup_paths:
-            Util.restore_backup(backup_path)
-        self.backup_paths = []
+        if self.backup_path:
+            Util.restore_backup(self.backup_path)
+        self.backup_path = None
 
     def submit_soroban(self) -> None:
 
@@ -930,12 +931,14 @@ class MutateApp:
         # run mutants
         mutant_runs = []
         try:
-            self.backup_paths = []
             for mutant in all_mutants:
                 # call certoraRun for each mutant we found
                 mutant_runs.append(self.run_mutant_soroban(mutant))
+                self.restore_backups()
         finally:
-            self.restore_backups()
+            if self.backup_path:
+                mutation_logger.warning("Not empty backup path")
+                self.restore_backups()
 
         # wrap it all up and make the input for the 2nd step: the collector
         assert self.collect_file, "submit_soroban: no collect_file"
@@ -1143,10 +1146,11 @@ class MutateApp:
     def run_mutant_soroban(self, mutant: Mutant) -> MutantJob:
         file_to_mutate = Path(mutant.original_filename)
         # create a backup copy (if needed) by adding '.backup' to the end of the file
-        if Util.get_backup_path(file_to_mutate) not in self.backup_paths:
-            backup_file = Util.create_backup(file_to_mutate)
-            assert backup_file, f"run_mutant_soroban: create_backup for {file_to_mutate} failed"
-            self.backup_paths.append(backup_file)
+        if self.backup_path and Util.get_backup_path(file_to_mutate) != self.backup_path:
+            raise Util.ImplementationError("backup_path is set but does not match the file to mutate")
+        if not self.backup_path:
+            self.backup_path = Util.create_backup(file_to_mutate)
+            assert self.backup_path, f"run_mutant_soroban: create_backup for {file_to_mutate} failed"
         shutil.copy(mutant.filename, file_to_mutate)
 
         try:
@@ -1182,6 +1186,7 @@ class MutateApp:
         if solc:
             compiler = solc
         elif compiler_map:
+            Cv.check_contract_name_arg_inputs(self.prover_context)
             compiler = get_relevant_compiler(path_to_file, self.prover_context)
             if not compiler:
                 raise Util.CertoraUserInputError(f"Cannot resolve Solidity compiler for {path_to_file}: "
@@ -1257,6 +1262,8 @@ class MutateApp:
         for gambit_obj in self.gambit:
             if MConstants.NUM_MUTANTS not in gambit_obj:
                 gambit_obj[MConstants.NUM_MUTANTS] = DEFAULT_NUM_MUTANTS
+            else:
+                gambit_obj[MConstants.NUM_MUTANTS] = int(gambit_obj[MConstants.NUM_MUTANTS])
             gambit_obj[MConstants.SOLC] = self.get_solc_version(Path(gambit_obj[MConstants.FILENAME]))
             gambit_obj.update(shared_attributes)
         with MConstants.TMP_GAMBIT_PATH.open('w') as f:
@@ -1375,7 +1382,7 @@ class MutateApp:
         for mutant in self.universal_mutator:
             file_to_mutate = Path(os.path.normpath(mutant[MConstants.FILE_TO_MUTATE]))
             mutants_location = Path(mutant[MConstants.MUTANTS_LOCATION])
-            num_of_mutants = mutant[MConstants.NUM_MUTANTS]
+            num_of_mutants = int(mutant[MConstants.NUM_MUTANTS])
             run_universal_mutator(file_to_mutate, self.prover_context.build_script, mutants_location, num_of_mutants)
             self.add_dir_to_mutants(ret_mutants, mutants_location, file_to_mutate)
         return ret_mutants
@@ -1405,6 +1412,8 @@ class MutateApp:
         certora_args = [str(conf_file), "--run_source", "MUTATION", "--msg", msg]
         if self.wait_for_original_run:
             certora_args.append("--wait_for_results")
+        if self.url_visibility:
+            certora_args.extend(["--url_visibility", str(self.url_visibility)])
         if self.with_split_stats_data and os.environ.get("WITH_AUTOCONFING", False) == '1':
             certora_args += ['--prover_resource_files', f"ac:{MConstants.SPLIT_STATS_DATA}"]
         if mutation_test_id:
@@ -1872,7 +1881,7 @@ class MutateApp:
 
         with open(self.conf, 'r') as conf_file:
             try:
-                self.prover_context = CertoraContext(**json5.load(conf_file, allow_duplicate_keys=False))
+                self.prover_context = CertoraContext(**Util.read_conf_file(conf_file))
                 self.check_prover_context()
             except Exception as e:
                 raise Util.CertoraUserInputError(f"Failed to parse {self.conf} as JSON", e)
@@ -1915,7 +1924,9 @@ class MutateApp:
         if not self.manual_mutants:
             return
 
-        solc = self.get_solc_version(trg_dir)
+        solc = self.get_solc_version(Path(mutant.original_filename))
+        if not solc:
+            raise Util.CertoraUserInputError(f"Unable to find a compiler for manual mutant {mutant.original_filename}")
 
         via_ir_flag = []
         if getattr(self.prover_context, MConstants.SOLC_VIA_IR, '') or \
@@ -1926,10 +1937,11 @@ class MutateApp:
         if self.test == str(Util.TestValue.CHECK_MANUAL_COMPILATION):
             raise Util.TestResultsReady(' '.join(args))
         with Util.change_working_directory(find_cwd(trg_dir)):
-            result = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            result = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
         if result.returncode:
             mutation_logger.debug(f"mutation compilation failed: cmd: {' '.join(args)}\n cwd: {os.getcwd()}")
-            raise Util.CertoraUserInputError(f"mutation file {mutant.filename} failed to compile")
+            raise Util.CertoraUserInputError(f"mutation file {mutant.filename} failed to compile\n\n"
+                                             f"{result.stderr.decode()}")
 
 
 def rec_collect_statuses_children(rule: Dict[str, Any], statuses: List[str]) -> None: