certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 8.5.0__py3-none-any.whl

certora_cli/Shared/certoraValidateFuncs.py

@@ -18,6 +18,8 @@ import sys
 import argparse
 import json
 import logging
+from collections import OrderedDict
+
 import json5
 import re
 import urllib3.util
@@ -89,7 +91,7 @@ class RunSources(Util.NoValEnum):
     MUTATION = auto()
     BENCHMARK = auto()
     LIGHT_TEST = auto()
-    RERUN = auto()
+    REPORT = auto()
 
 
 class WaitForResultOptions(Util.NoValEnum):
@@ -97,6 +99,11 @@ class WaitForResultOptions(Util.NoValEnum):
     ALL = auto()
 
 
+class UrlVisibilityOptions(Util.NoValEnum):
+    PRIVATE = auto()
+    PUBLIC = auto()
+
+
 def is_solc_file_valid(orig_filename: Optional[str]) -> str:
     """
     Verifies that a given --solc argument is valid:
@@ -122,7 +129,7 @@ def is_solc_file_valid(orig_filename: Optional[str]) -> str:
         if filename.endswith(f".{suffix}"):
             raise Util.CertoraUserInputError(f"wrong Solidity executable given: {filename}")
 
-    # see https://docs.python.org/3.8/library/shutil.html#shutil.which. We use no mask to give a precise error
+    # see https://docs.python.org/3.9/library/shutil.html#shutil.which. We use no mask to give a precise error
     solc_location = shutil.which(filename, os.F_OK)
     if solc_location is not None:
         solc_path = Path(solc_location)
@@ -423,7 +430,7 @@ def validate_contract_extension_attr(map: Any) -> Dict[str, List[Dict[str, Any]]
     return map
 
 
-def validate_input_file(file: str) -> str:
+def validate_evm_input_file(file: str) -> str:
     # [file[:contractName] ...] or CONF_FILE.conf or TAC_FILE.tac
 
     if Util.SOL_EXT in file:
@@ -467,12 +474,12 @@ def validate_input_file(file: str) -> str:
         except Exception as e:
             raise Util.CertoraUserInputError(f"Cannot access file {file} : {e}")
         return file
-    elif any(file.endswith(ext) for ext in Util.VALID_FILE_EXTENSIONS):
+    elif any(file.endswith(ext) for ext in Util.VALID_EVM_EXTENSIONS):
         validate_readable_file(file)
         return file
 
     raise Util.CertoraUserInputError(
-        f"input file {file} is not in one of the supported types ({Util.VALID_FILE_EXTENSIONS})")
+        f"input file {file} is not in one of the supported types ({Util.VALID_EVM_EXTENSIONS})")
 
 
 def validate_json_file(file: str) -> str:
@@ -543,12 +550,12 @@ def validate_struct_link(link: str) -> str:
     return link
 
 
-def validate_assert_contracts(contract: str) -> str:
-    if not re.match(Util.SOLIDITY_ID_STRING_RE, contract):
+def validate_equivalence_contracts(equiv_string: str) -> str:
+    if not re.match(f'^{Util.SOLIDITY_ID_SUBSTRING_RE}={Util.SOLIDITY_ID_SUBSTRING_RE}$', equiv_string):
         raise Util.CertoraUserInputError(
-            f"Contract name {contract} can include only alphanumeric characters, dollar signs or underscores")
-    return contract
-
+            f"Equivalence check must be ContractA=ContractB, got {equiv_string}"
+        )
+    return equiv_string
 
 def validate_packages(package: str) -> str:
     if not re.search("^[^=]+=[^=]+$", package):
@@ -660,14 +667,14 @@ def validate_address(value: str) -> str:
     return value
 
 
-def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
+def validate_boolean_map(args: Dict[str, bool], attr_name: str) -> None:
+    attr_map_name = attr_name + "_map"
     if not isinstance(args, dict):
-        raise Util.CertoraUserInputError("'solc_via_ir_map' should be stored as a map "
-                                         f"(type was {type(args).__name__})")
+        raise Util.CertoraUserInputError(f"'{attr_map_name}' should be stored as a map (type was {type(args).__name__})")
 
     for contract, value in args.items():
         if not isinstance(value, bool):
-            raise Util.CertoraUserInputError(f"'solc_via_ir_map' should map {contract} to a boolean value, "
+            raise Util.CertoraUserInputError(f"'{attr_map_name}' should map {contract} to a boolean value, "
                                              f"got ({value}, type: {type(value).__name__})")
 
     values = args.values()
@@ -675,9 +682,15 @@ def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
 
     if all(x == first for x in values):
         if first:
-            validation_logger.warning("all via_ir values are set to True '--solc_via_ir' can be used instead")
+            validation_logger.warning(f"all {attr_map_name} values are set to True '{attr_name}' can be used instead")
         else:
-            validation_logger.warning("all via_ir values are set to False, this flag/attribute  can be omitted")
+            validation_logger.warning(f"all {attr_map_name} values are set to False, this flag/attribute can be omitted")
+
+def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
+    validate_boolean_map(args, 'solc_via_ir')
+
+def validate_vyper_venom_map(args: Dict[str, bool]) -> None:
+    validate_boolean_map(args, 'vyper_venom')
 
 def validate_solc_evm_version_map(args: Dict[str, str]) -> None:
     if not isinstance(args, dict):
@@ -751,8 +764,18 @@ def validate_git_hash(git_hash: str) -> str:
         raise Util.CertoraUserInputError("Git hash must consist of between 1 and 40 characters")
     return git_hash
 
+def validate_check_method_flag(method: str) -> str:
+    if '.' in method:
+        raise Util.CertoraUserInputError(f"Malformed `check_mathod` argument '{method}': checked method cannot contain a dot. Use only the method name without the contract prefix."
+                                         "the contract part is not allowed in `--check_method`")
+    if ' ' in method:
+        raise Util.CertoraUserInputError(f"Malformed method '{method}' in `--check_method`: remove all whitespace")
+
+    if not __validate_matching_parens(method):
+        raise Util.CertoraUserInputError(f"Malformed method '{method}' in `--check_method`: unmatched parenthesis")
+    return method
 
-def validate_method_flag(method: str) -> str:
+def validate_evm_method_flag(method: str) -> str:
     contract_and_method = method.split('.')
     if len(contract_and_method) > 2:
         raise Util.CertoraUserInputError(f"Malformed method '{method}' in `--method` list: a method should be of the form `[ContractName.]functionABISignature(...)`")
@@ -771,6 +794,8 @@ def validate_method_flag(method: str) -> str:
 
     return method
 
+def validate_move_method_flag(method: str) -> str:
+    return validate_move_function_name(method)
 
 def __validate_matching_parens(s: str) -> bool:
     stack = []
@@ -806,17 +831,30 @@ def __validate_solidity_id(string: str, object: str) -> str:
 def validate_contract_name(contract_name: str) -> str:
     return __validate_solidity_id(contract_name, "contract")
 
-
-def validate_rule_name(rule_str: str) -> str:
-    if ("*" not in rule_str):
-        return __validate_solidity_id(rule_str, "rule")
-
-    # we have a rule pattern string
+def validate_rule_pattern_string(rule_str: str) -> str:
     if not re.match(r"^[a-zA-Z0-9_$*]+$", rule_str):
         raise Util.CertoraUserInputError(f"invalid rule pattern \"{rule_str}\": rule patterns must contain only "
                                          "letters, digits, dollar signs, underscores, or asterisks")
     return rule_str
 
+def validate_evm_rule_name(rule_str: str) -> str:
+    if ("*" in rule_str):
+        return validate_rule_pattern_string(rule_str)
+    else:
+        return __validate_solidity_id(rule_str, "rule")
+
+def validate_move_function_name(name: str) -> str:
+    if not re.match(r"^(0x[0-9a-fA-F]+|([a-zA-Z_][a-zA-Z0-9_]*))::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$", name):
+        raise Util.CertoraUserInputError(f"invalid Move function name \"{name}\": must be a fully-qualified Move "
+                                         "function name")
+    return name
+
+def validate_move_rule_name(rule_str: str) -> str:
+    if ("*" in rule_str):
+        return validate_rule_pattern_string(rule_str)
+    else:
+        return validate_move_function_name(rule_str)
+
 
 MAX_MSG_LEN: int = 256
 
@@ -827,7 +865,7 @@ def validate_msg(msg: str) -> str:
         msg = (msg[:MAX_MSG_LEN - 3] + "...")
         validation_logger.warning(f"'msg' can't accept strings longer than {MAX_MSG_LEN} chars, string was truncated")
 
-    additional_chars = {'(', ' ', ',', '/', '[', "'", '-', '"', '_', ']', '.', ')', ':', '\\', '='}
+    additional_chars = {'(', ' ', ',', '/', '[', "'", '-', '"', '_', ']', '.', ')', ':', '\\', '=', '*', '$'}
     valid_chars = set(string.ascii_letters) | set(string.digits) | additional_chars
     invalid_chars = set(msg) - valid_chars
     if len(invalid_chars) > 0:
@@ -931,7 +969,7 @@ def validate_on_off(value: str) -> str:
     return __validate_enum_value(value, OnOffValue)
 
 
-def parse_dict(conf_key: str, input_string: str, value_type: Type = str) -> Dict[str, Union[str, bool]]:
+def parse_ordered_dict(conf_key: str, input_string: str, value_type: Type = str) -> OrderedDict[str, Union[str, bool]]:
     """
     convert CLI flag value string of the form <key>=<value>,<key>=<value>,.. to a Dict.
     Keys with different values raise an exception
@@ -964,7 +1002,7 @@ def parse_dict(conf_key: str, input_string: str, value_type: Type = str) -> Dict
         raise argparse.ArgumentTypeError(f"{conf_key} argument {input_string} is of wrong format. Must be of format:"
                                          f"<key>=<value>[,..]")
 
-    return_dict = {}  # type: Dict[str, Union[str, bool]]
+    return_dict = OrderedDict()  # type: OrderedDict[str, Union[str, bool]]
 
     for match in input_string.split(','):
         key, value = match.split('=')
@@ -986,6 +1024,10 @@ def validate_wait_for_results(value: str) -> str:
     return __validate_enum_value(value, WaitForResultOptions)
 
 
+def validate_url_visibility(value: str) -> str:
+    return __validate_enum_value(value, UrlVisibilityOptions)
+
+
 def validate_json5_file(file: str) -> str:
     file_exists_and_readable(file)
 

certora_cli/Shared/proverCommon.py

@@ -0,0 +1,308 @@
+#     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/>.
+
+"""
+Shared helpers for certoraRun entry points (Solana & Soroban & EVM).
+
+Placing the context_build environment preparation logic and verification helpers in one module
+reduces duplication from the dedicated entry scripts.
+"""
+
+from __future__ import annotations
+
+import sys
+import logging
+import functools
+from pathlib import Path
+from dataclasses import dataclass
+from rich.console import Console
+from typing import List, Tuple, Type, Optional, Dict, NoReturn, Callable
+from os import getenv
+
+scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+from CertoraProver.certoraCloudIO import validate_version_and_branch
+from Shared.certoraLogging import LoggingManager
+from Shared import certoraUtils as Util
+import CertoraProver.certoraContext as Ctx
+from CertoraProver.certoraContextClass import CertoraContext
+import CertoraProver.certoraContextAttributes as Attrs
+from CertoraProver.certoraCollectRunMetadata import collect_run_metadata
+from CertoraProver.certoraCollectConfigurationLayout import collect_configuration_layout
+from CertoraProver import certoraContextValidator as Cv
+from CertoraProver.certoraCloudIO import CloudVerification
+import CertoraProver.certoraApp as App
+
+log = logging.getLogger(__name__)
+
+
+VIOLATIONS_EXIT_CODE = 100
+
+@dataclass
+class CertoraRunResult:
+    link: Optional[str]  # Path to emv_dir if running locally, or the link to the job status page
+    is_local_link: bool
+    src_dir: Path
+    rule_report_link: Optional[str]
+
+class CertoraFoundViolations(Exception):
+    def __init__(self, message: str, results: Optional[CertoraRunResult] = None) -> None:
+        super().__init__(message)
+        self.results = results
+
+# --------------------------------------------------------------------------- #
+# Setup Environment
+# --------------------------------------------------------------------------- #
+def build_context(args: List[str], app: Type[App.CertoraApp]) -> Tuple[CertoraContext, LoggingManager]:
+    """
+    Build the context for the Certora Prover.
+    This function is responsible for setting up the context and logging manager
+    for the Certora Prover. It handles the following tasks:
+    1. Setting up the logging manager
+    2. Parsing the command line arguments
+    3. Setting up the context
+
+    Args:
+        args: The command line arguments to parse.
+        app: The application
+    Returns:
+        A tuple containing the CertoraContext object and the LoggingManager object.
+    """
+    Attrs.set_attribute_class(app.attr_class)
+    non_str_els = [x for x in args if not isinstance(x, str)]
+    if non_str_els:
+        print(f"args for run_certora that are not strings: {non_str_els}")
+        exit(1)
+
+    # If we are not in debug mode, we do not want to print the traceback in case of exceptions.
+    if '--debug' not in args:  # We check manually, because we want no traceback in argument parsing exceptions
+        sys.tracebacklimit = 0
+
+    # creating the default internal dir, files may be copied to user defined build directory after
+    # parsing the input
+
+    if not ('--help' in args or '--version' in args):
+        Util.reset_certora_internal_dir()
+        Util.safe_create_dir(Util.get_build_dir())
+        logging_manager = LoggingManager()
+
+    Ctx.handle_flags_in_args(args, app)
+    context = Ctx.get_args(args, app)  # Parse arguments
+
+    assert logging_manager, "logging manager was not set"
+    logging_manager.set_log_level_and_format(is_quiet=Ctx.is_minimal_cli_output(context),
+                                             debug=context.debug,
+                                             debug_topics=context.debug_topics,
+                                             show_debug_topics=context.show_debug_topics)
+
+    return context, logging_manager
+
+
+def collect_and_dump_metadata(context: CertoraContext) -> None:
+    """
+    Collect and validate run metadata.
+
+    Args:
+        context: The Certora context containing verification settings
+
+    Raises:
+        Util.TestResultsReady: If this is a metadata test run
+    """
+    metadata = collect_run_metadata(wd=Path.cwd(), raw_args=sys.argv, context=context)
+
+    if context.test == str(Util.TestValue.CHECK_METADATA):
+        raise Util.TestResultsReady(metadata)
+
+    metadata.dump()
+
+
+def collect_and_dump_config_layout(context: CertoraContext) -> None:
+    """
+    Collect and dump the configuration layout.
+
+    Args:
+        context: The Certora context containing verification settings
+
+    Raises:
+        Util.TestResultsReady: If this is a configuration layout test run
+    """
+    configuration_layout = collect_configuration_layout()
+
+    if context.test == str(Util.TestValue.CHECK_CONFIG_LAYOUT):
+        raise Util.TestResultsReady(configuration_layout)
+
+    configuration_layout.dump()
+
+
+def ensure_version_compatibility(context: CertoraContext) -> None:
+    if not (context.local or context.build_only or context.compilation_steps_only):
+        """
+        Before running the local type checker, we see if the current package version is compatible with
+        the latest. We check it before running the local type checker, because local type checking
+        errors could be simply a result of syntax introduced in the newest version.
+        The line below will raise an exception if the local version is incompatible.
+        """
+        validate_version_and_branch(context)
+
+
+# --------------------------------------------------------------------------- #
+# Verification helpers
+# --------------------------------------------------------------------------- #
+
+def run_local(context: CertoraContext, timings: Dict, additional_commands: Optional[List[str]] = None,
+              compare_with_expected_file: bool = False) -> int:
+    """
+    Run the verifier locally and return its exit code (0 = success).
+    Args:
+        context: The CertoraContext object containing the configuration.
+        timings: A dictionary to store timing information.
+        additional_commands: A list of additional commands to pass to the verifier.
+    Returns:
+        An integer representing the exit code of the verifier run.
+    """
+    cmd: List[str] = Ctx.get_local_run_cmd(context)
+
+    if additional_commands:
+        cmd.extend(additional_commands)
+
+    print(f'Verifier run command:\n {" ".join(cmd)}')
+    if context.test == str(Util.TestValue.BEFORE_LOCAL_PROVER_CALL):
+        raise Util.TestResultsReady(' '.join(cmd))
+    rc = Util.run_jar_cmd(
+        cmd,
+        override_exit_code=compare_with_expected_file,
+        logger_topic="verification",
+        print_output=True,
+    )
+
+    if rc == 0:
+        Util.print_completion_message("Finished running verifier:")
+        print(f'\t{" ".join(cmd)}')
+        timings.setdefault("buildTime", 0.0)  # ensure key exists
+        return 0
+
+    return 1
+
+
+def run_remote(
+    context: CertoraContext,
+    args: List[str],
+    timings: Dict,
+) -> Tuple[int, Optional[CertoraRunResult]]:
+    """
+    Run verification in Certora Cloud.
+
+    Args:
+        context: The CertoraContext object containing the configuration.
+        args: The command line arguments to pass to the cloud verification.
+        timings: A dictionary to store timing information.
+    Returns:
+        A tuple containing the exit code (0 = success) and an optional CertoraRunResult object.
+    """
+    if context.compilation_steps_only:
+        return 0, CertoraRunResult(None, False, Util.get_certora_sources_dir(), None)
+
+    context.key = Cv.validate_certora_key()
+    cloud = CloudVerification(context, timings)
+
+    pretty_args = [f"'{a}'" if " " in a else a for a in args]
+
+    ok = cloud.cli_verify_and_report(" ".join(pretty_args), context.wait_for_results)
+
+    exit_code = 0 if ok else VIOLATIONS_EXIT_CODE
+    result: Optional[CertoraRunResult] = None
+    if cloud.statusUrl:
+        result = CertoraRunResult(
+            cloud.statusUrl,
+            False,
+            Util.get_certora_sources_dir(),
+            cloud.reportUrl,
+        )
+    return exit_code, result
+
+
+def handle_exit(exit_code: int, return_value: Optional[CertoraRunResult]) -> Optional[CertoraRunResult]:
+    """
+    Handle the exit code of the verification run.
+    Args:
+        exit_code: The exit code of the verification run.
+        return_value: The CertoraRunResult object containing the results of the verification run.
+    Raises:
+        CertoraFoundViolations: If violations were found during the verification run.
+        Util.CertoraUserInputError: If there was an error with the user input.
+    Returns:
+        The CertoraRunResult object containing the results of the verification run.
+    """
+    if exit_code == VIOLATIONS_EXIT_CODE:
+        raise CertoraFoundViolations("violations were found", return_value)
+    if exit_code != 0:
+        raise Util.CertoraUserInputError(f"run_certora failed (code {exit_code})")
+    return return_value
+
+
+# --------------------------------------------------------------------------- #
+# Entry point decorator
+# --------------------------------------------------------------------------- #
+
+console = Console()
+
+def catch_exits(fn: Callable[..., None]) -> Callable[..., NoReturn]:
+    """
+    Wrap any entry-point in a standard try/except + sys.exit logic.
+    The wrapped function should do its work and then return normally;
+    this decorator will exit(0) on success or exit(1/other) on failure.
+    """
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs) -> NoReturn:   # type: ignore
+        try:
+            fn(*args, **kwargs)
+            sys.exit(0)
+
+        except KeyboardInterrupt:
+            console.print("[bold red]\nInterrupted by user")
+            sys.exit(1)
+
+        except Util.TestResultsReady:
+            print("reached checkpoint")
+            sys.exit(0)
+
+        except CertoraFoundViolations as e:
+            link = getattr(e.results, "rule_report_link", None)
+            if link:
+                print(f"report url: {link}")
+            console.print("[bold red]\nViolations were found\n")
+            sys.exit(1)
+
+        except Util.CertoraUserInputError as e:
+            if e.orig:
+                print(f"\n{str(e.orig).strip()}")
+            if e.more_info:
+                print(f"\n{e.more_info.strip()}")
+            console.print(f"[bold red]\n{e}\n")
+            sys.exit(1)
+
+        except Util.ExitException as e:
+            console.print(f"[bold red]{e}")
+            sys.exit(e.exit_code)
+
+        except Exception as e:
+            console.print(f"[bold red]{e}")
+            if getenv('CERTORA_DEV_MODE'):
+                import traceback
+                console.print(f"Traceback: {traceback.format_exc()}")
+            sys.exit(1)
+
+    return wrapper

certora_cli/certoraCVLFormatter.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import os
+import sys
+import argparse
+import subprocess
+from pathlib import Path
+
+scripts_dir_path = Path(__file__).parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+from Shared import certoraUtils as Util
+from pathlib import Path
+
+FORMATTER_JAR = "ASTExtraction.jar"
+
+scripts_dir_path = Path(__file__).parent.resolve()
+sys.path.insert(0, str(scripts_dir_path))
+
+def spec_file_type(spec_file: str) -> str:
+    if not os.path.isfile(spec_file):
+        raise argparse.ArgumentTypeError(f"File {spec_file} does not exist")
+    return spec_file
+
+def run_formatter_from_jar(spec_file: str, overwrite: bool) -> None:
+    path_to_typechecker = Util.find_jar(FORMATTER_JAR)
+    cmd = ['java', '-jar', str(path_to_typechecker), 'format', '--file', spec_file]
+
+    result = subprocess.run(cmd, text=True, capture_output=True)
+
+    if result.returncode != 0:
+        raise Util.CertoraUserInputError(f"Error running formatter on {spec_file}: {result.stderr.strip() if result.stderr else ''}")
+
+    if overwrite:
+        with open(spec_file, 'w', encoding='utf-8') as f:
+            f.write(result.stdout)
+    else:
+        print(result.stdout, end='', file=sys.stdout)
+
+def parse_args() -> tuple[str, bool]:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('spec_file', type=spec_file_type, help='Path to the .spec file')
+    parser.add_argument('-w', '--overwrite', action='store_true', help='If set, output is written to the spec file instead of stdout')
+
+    args = parser.parse_args()
+    return args.spec_file, args.overwrite
+
+
+def check_java_version() -> None:
+    if not (Util.is_java_installed(Util.get_java_version())):
+        raise Util.CertoraUserInputError(f"Java {Util.MIN_JAVA_VERSION} or higher is required to run the formatter. "
+                                         f"Please install Java and try again.")
+
+
+def entry_point() -> None:
+    spec_file, overwrite = parse_args()
+    check_java_version()
+    run_formatter_from_jar(spec_file, overwrite)
+
+if __name__ == '__main__':
+    entry_point()

certora_cli/certoraConcord.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import sys
+from pathlib import Path
+
+scripts_dir_path = Path(__file__).parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+import CertoraProver.certoraApp as App
+from certoraRun import run_certora
+from Shared.proverCommon import CertoraRunResult, catch_exits
+
+from typing import List, Optional
+
+
+def run_concord(args: List[str]) -> Optional[CertoraRunResult]:
+    return run_certora(args, App.ConcordApp, prover_cmd=sys.argv[0])
+
+@catch_exits
+def entry_point() -> None:
+    run_concord(sys.argv[1:])
+
+if __name__ == '__main__':
+    entry_point()

certora_cli/certoraEVMProver.py

@@ -21,13 +21,14 @@ from pathlib import Path
 scripts_dir_path = Path(__file__).parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
 
-import CertoraProver.certoraContextAttributes as Attrs
-from certoraRun import run_certora, CertoraRunResult
+import CertoraProver.certoraApp as App
+from Shared.proverCommon import CertoraRunResult
+from certoraRun import run_certora
 from typing import List, Optional
 
 
 def run_evm_prover(args: List[str]) -> Optional[CertoraRunResult]:
-    return run_certora(args, Attrs.EvmProverAttributes)
+    return run_certora(args, App.EvmApp)
 
 def entry_point() -> None:
     run_evm_prover(sys.argv[1:])