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

certora_cli/Mutate/mutateAttributes.py

@@ -250,6 +250,17 @@ class MutateAttributes(AttrUtil.Attributes):
         }
     )
 
+    URL_VISIBILITY = MutateAttributeDefinition(
+        attr_validation_func=Vf.validate_url_visibility,
+        argparse_args={
+            'nargs': AttrUtil.SINGLE_OR_NONE_OCCURRENCES,
+            'action': AttrUtil.UniqueStore,
+            'default': None,  # 'default': when --url_visibility was not used
+            # when --url_visibility was used without an argument its probably because the link should be public
+            'const': str(Vf.UrlVisibilityOptions.PUBLIC)
+        }
+    )
+
 
 def get_args(args_list: List[str]) -> Dict:
 

certora_cli/Mutate/mutateValidate.py

@@ -118,8 +118,8 @@ class MutateValidator:
 
         if value is None:
             raise RuntimeError(f"calling validate_type_string with null value {key}")
-        if not isinstance(value, str) and not isinstance(value, Path):
-            raise Util.CertoraUserInputError(f"value of {key} {value} is not a string")
+        if not isinstance(value, (str, Path, int)):
+            raise Util.CertoraUserInputError(f"value of {key} {value} is not a string, integer, or Path")
         attr.validate_value(str(value))
 
     def validate_type_any(self, attr: AttrUtil.AttributeDefinition) -> None:

certora_cli/Shared/certoraAttrUtil.py

@@ -167,9 +167,12 @@ class Attributes:
         table.add_column(Text("Description"), width=desc_col_width)
         table.add_column(Text("Default"), width=default_col_width)
 
+        unsupported_attribute_names = [attr.name for attr in cls.unsupported_attributes()]
         for name in dir(cls):
             if name in cls.hide_attributes():
                 continue
+            if name in unsupported_attribute_names:
+                continue
             if name.isupper():
                 attr = getattr(cls, name, None)
                 assert isinstance(attr, AttributeDefinition), "print_attr_help: type(attr) == Attribute"
@@ -190,11 +193,9 @@ class Attributes:
             v.name = name
             return v
 
-        if not cls._attribute_list:
-            cls._attribute_list = [set_name(name) for name in dir(cls) if name.isupper()]
-            cls._all_conf_names = [attr.name.lower() for attr in cls.attribute_list()]
-            #  'compiler_map' does not have a matching 'compiler' attribute
-            cls._all_map_attrs = [attr for attr in cls._all_conf_names if attr.endswith(Util.MAP_SUFFIX)]
+        cls._attribute_list = [set_name(name) for name in dir(cls) if name.isupper()]
+        cls._all_conf_names = [attr.name.lower() for attr in cls.attribute_list()]
+        cls._all_map_attrs = [attr for attr in cls._all_conf_names if attr.endswith(Util.MAP_SUFFIX)]
 
     @classmethod
     def hide_attributes(cls) -> List[str]:
@@ -203,3 +204,8 @@ class Attributes:
         :return: A list of attribute names to be hidden.
         """
         return []
+
+    @classmethod
+    def unsupported_attributes(cls) -> list:
+        # Return a list of AttributeDefinition objects that are unsupported
+        return []

certora_cli/Shared/certoraUtils.py

@@ -16,6 +16,7 @@
 import csv
 import json
 import os
+import io
 import subprocess
 from abc import ABCMeta
 from enum import Enum, unique, auto
@@ -30,8 +31,9 @@ import urllib3.util
 from collections import defaultdict
 from types import SimpleNamespace
 
-from typing import Any, Callable, Dict, List, Optional, Set, Union, Generator, Tuple, Iterable, Sequence, TypeVar
+from typing import Any, Callable, Dict, List, Optional, Set, Union, Generator, Tuple, Iterable, Sequence, TypeVar, OrderedDict
 from pathlib import Path
+import json5
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
@@ -90,6 +92,7 @@ CERTORA_RUN_SCRIPT = "certoraRun.py"
 CERTORA_RUN_APP = "certoraRun"
 PACKAGE_FILE = Path("package.json")
 REMAPPINGS_FILE = Path("remappings.txt")
+FOUNDRY_TOML_FILE = Path("foundry.toml")
 RECENT_JOBS_FILE = Path(".certora_recent_jobs.json")
 LAST_CONF_FILE = Path("run.conf")
 EMV_JAR = Path("emv.jar")
@@ -114,7 +117,8 @@ EVM_SOURCE_EXTENSIONS = (SOL_EXT, VY_EXT, YUL_EXT)
 EVM_EXTENSIONS = EVM_SOURCE_EXTENSIONS + ('.tac', '.json')
 SOLANA_EXEC_EXTENSION = '.so'
 SOROBAN_EXEC_EXTENSION = '.wasm'
-VALID_FILE_EXTENSIONS = ['.conf'] + list(EVM_EXTENSIONS) + [SOLANA_EXEC_EXTENSION, SOROBAN_EXEC_EXTENSION]
+VALID_EVM_EXTENSIONS = list(EVM_EXTENSIONS) + ['.conf']
+VALID_FILE_EXTENSIONS = VALID_EVM_EXTENSIONS + [SOLANA_EXEC_EXTENSION, SOROBAN_EXEC_EXTENSION]
 # Type alias definition, not a variable
 CompilerVersion = Tuple[int, int, int]
 MAP_SUFFIX = '_map'
@@ -368,11 +372,8 @@ def remove_file(file_path: Union[str, Path]) -> None:  # TODO - accept only Path
         except OSError:
             pass
     else:
-        try:
-            # When we upgrade to Python 3.8, we can use unlink(missing_ok=True) and remove the try/except clauses
-            file_path.unlink()
-        except FileNotFoundError:
-            pass
+        file_path.unlink(missing_ok=True)
+
 
 def abs_norm_path(file_path: Union[str, Path]) -> Path:
     """
@@ -959,18 +960,6 @@ def flatten_set_list(set_list: List[Set[Any]]) -> List[Any]:
     return list(ret_set)
 
 
-def is_relative_to(path1: Path, path2: Path) -> bool:
-    """certora-cli currently requires python3.8 and it's the last version without support for is_relative_to.
-    Shamelessly copying.
-    """
-    # return path1.is_relative_to(path2)
-    try:
-        path1.relative_to(path2)
-        return True
-    except ValueError:
-        return False
-
-
 def find_jar(jar_name: str) -> Path:
     # if we are a dev running certoraRun.py (local version), we want to get the local jar
     # if we are a dev running an installed version of certoraRun, we want to get the installed jar
@@ -982,7 +971,7 @@ def find_jar(jar_name: str) -> Path:
 
     if certora_home != "":
         local_certora_path = Path(certora_home) / CERTORA_JARS / jar_name
-        if is_relative_to(Path(__file__), Path(certora_home)) and local_certora_path.is_file():
+        if Path(__file__).is_relative_to(Path(certora_home)) and local_certora_path.is_file():
             return local_certora_path
 
     return get_package_resource(CERTORA_JARS / jar_name)
@@ -997,31 +986,46 @@ def get_package_resource(resource: Path) -> Path:
     return Path(__file__).parents[2] / resource
 
 
-def is_java_installed() -> bool:
+def get_java_version() -> str:
     """
-    Check that java is installed and with a version that is suitable for running certora jars
-    @return True on success
+    Retrieve installed java version
+    @return installed java version on success or empty string
     """
     # Check if java exists on the machine
     java = which("java")
     if java is None:
+        return ''
+
+    try:
+        java_version_str = subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT).decode()
+        java_version = re.search(r'version \"([\d\.]+)\"', java_version_str).groups()[0]  # type: ignore[union-attr]
+
+        return java_version
+    except (subprocess.CalledProcessError, AttributeError):
+        typecheck_logger.debug("Couldn't find the installed Java version.")
+        return ''
+
+
+def is_java_installed(java_version: str) -> bool:
+    """
+    Check that java is installed and with a version that is suitable for running certora jars
+    @return True on success
+    """
+    if not java_version:
         typecheck_logger.warning(
             f"`java` is not installed. Installing Java version {MIN_JAVA_VERSION} or later will enable faster "
             f"CVL specification syntax checking before uploading to the cloud.")
         return False
 
-    try:
-        java_version_str = subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT).decode()
-        major_java_version = re.search(r'version \"(\d+).*', java_version_str).groups()[0]  # type: ignore[union-attr]
+    else:
+        major_java_version = java_version.split('.')[0]
         if int(major_java_version) < MIN_JAVA_VERSION:
             typecheck_logger.warning("Installed Java version is too old to check CVL specification files locally. "
                                      f" Java version should be at least {MIN_JAVA_VERSION} to allow local java-based "
                                      "type checking")
 
             return False
-    except (subprocess.CalledProcessError, AttributeError):
-        typecheck_logger.warning("Couldn't find the installed Java version.")
-        return False
+
     return True
 
 
@@ -1349,25 +1353,49 @@ def is_local(object: Any) -> bool:
     default_jar_path = Path(certora_root_dir) / EMV_JAR
     return getattr(object, 'jar', None) or (default_jar_path.is_file() and not getattr(object, 'server', None))
 
+def get_mappings_from_forge_remappings() -> List[str]:
+    remappings_output = ""
+    try:
+        result = subprocess.run(['forge', 'remappings'], capture_output=True, text=True, check=True)
+        remappings_output = result.stdout
+    except Exception as e:
+        context_logger.debug(f"get_mappings_from_forge_remappings: forge failed to run\n{e}")
+
+    remappings = []
+    if remappings_output:
+        for line in remappings_output.strip().split('\n'):
+            if '=' in line:
+                remappings.append(line.strip())
+
+    return remappings
+
 
 def handle_remappings_file(context: SimpleNamespace) -> List[str]:
     """"
-    Tries to reach packages from remappings.txt
+    Tries to reach packages from remappings.txt.
+    If the file exists in cwd and foundry.toml does not exist in cwd we return the mappings in
+    the file (legacy implementation).
+    In all other cases we add the remappings returned from running the "forge remappings" command. Forge remappings
+    takes into consideration mappings in remappings.txt but also mappings in foundry.toml and mappings from auto scan
     :return:
     """
-    if REMAPPINGS_FILE.exists():
+    remappings = []
+    if REMAPPINGS_FILE.exists() and not FOUNDRY_TOML_FILE.exists():
         try:
             with REMAPPINGS_FILE.open() as remappings_file:
                 remappings = list(filter(lambda x: x != "", map(lambda x: x.strip(), remappings_file.readlines())))
                 keys = [s.split('=')[0] for s in remappings]
                 if len(set(keys)) < len(keys):
                     raise CertoraUserInputError(f"remappings.txt includes duplicated keys in: {keys}")
-                return remappings
         except CertoraUserInputError as e:
             raise e from None
         except Exception as e:
+            # create CertoraUserInputError from other exceptions
             raise CertoraUserInputError(f"Invalid remappings file: {REMAPPINGS_FILE}", e)
-    return []
+    elif find_nearest_foundry_toml():
+        remappings = get_mappings_from_forge_remappings()
+
+    return remappings
 
 
 def get_ir_flag(solc: str) -> str:
@@ -1436,14 +1464,33 @@ def eq_by(f: Callable[[T, T], bool], a: Sequence[T], b: Sequence[T]) -> bool:
     """
     return len(a) == len(b) and all(map(f, a, b))
 
-def find_nearest_cargo_toml() -> Optional[Path]:
+
+def find_file_in_parents(file_name: Union[Path, str]) -> Optional[Path]:
+    """
+    find file_name in current directory or in one of its parent directories
+    """
     current = Path.cwd()
     for parent in [current] + list(current.parents):
-        candidate = parent / CARGO_TOML_FILE
+        candidate = parent / str(file_name)
         if candidate.is_file():
             return candidate
     return None
 
+def find_nearest_cargo_toml() -> Optional[Path]:
+    """
+    Find the nearest Cargo.toml file in the current directory or its parent directories.
+    Returns the path to the Cargo.toml file if found, otherwise returns None.
+    """
+    return find_file_in_parents(CARGO_TOML_FILE)
+
+def find_nearest_foundry_toml() -> Optional[Path]:
+    """
+    Find the nearest foundry.toml file in the current directory or its parent directories.
+    Returns the path to the foundry.toml file if found, otherwise returns None.
+    """
+    return find_file_in_parents(FOUNDRY_TOML_FILE)
+
+
 def file_in_source_tree(file_path: Path) -> bool:
     # if the file is under .certora_source, return True
     file_path = Path(file_path).absolute()
@@ -1454,3 +1501,20 @@ def file_in_source_tree(file_path: Path) -> bool:
         return True
     except ValueError:
         return False
+
+def parse_int_as_str(val: str) -> str:
+    return str(val)
+
+def read_conf_file(file: io.TextIOWrapper) -> OrderedDict:
+    res = json5.load(file, allow_duplicate_keys=False, object_pairs_hook=OrderedDict, parse_int=parse_int_as_str)
+    return res
+
+def convert_str_ints(obj: Union[dict, list, str, int]) -> Union[dict, list, str, int]:
+    if isinstance(obj, dict):
+        return {k: convert_str_ints(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_str_ints(v) for v in obj]
+    elif isinstance(obj, str) and re.fullmatch(r"-?\d+", obj):
+        return int(obj)
+    else:
+        return obj

certora_cli/Shared/certoraValidateFuncs.py

@@ -91,7 +91,7 @@ class RunSources(Util.NoValEnum):
     MUTATION = auto()
     BENCHMARK = auto()
     LIGHT_TEST = auto()
-    RERUN = auto()
+    REPORT = auto()
 
 
 class WaitForResultOptions(Util.NoValEnum):
@@ -99,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:
@@ -124,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)
@@ -425,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:
@@ -469,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:
@@ -545,13 +550,6 @@ 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):
-        raise Util.CertoraUserInputError(
-            f"Contract name {contract} can include only alphanumeric characters, dollar signs or underscores")
-    return 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(
@@ -760,6 +758,16 @@ 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:
     contract_and_method = method.split('.')
@@ -995,6 +1003,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

@@ -36,7 +36,6 @@ 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
-from Shared.certoraAttrUtil import Attributes
 import CertoraProver.certoraContext as Ctx
 from CertoraProver.certoraContextClass import CertoraContext
 import CertoraProver.certoraContextAttributes as Attrs
@@ -44,6 +43,7 @@ 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__)
 
@@ -65,7 +65,7 @@ class CertoraFoundViolations(Exception):
 # --------------------------------------------------------------------------- #
 # Setup Environment
 # --------------------------------------------------------------------------- #
-def build_context(args: List[str], attributes: Type[Attributes]) -> Tuple[CertoraContext, LoggingManager]:
+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
@@ -76,11 +76,11 @@ def build_context(args: List[str], attributes: Type[Attributes]) -> Tuple[Certor
 
     Args:
         args: The command line arguments to parse.
-        attributes: The attributes class to use for the context. (e.g., SolanaProverAttributes or SorobanProverAttributes)
+        app: The application
     Returns:
         A tuple containing the CertoraContext object and the LoggingManager object.
     """
-    Attrs.set_attribute_class(attributes)
+    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}")
@@ -98,8 +98,8 @@ def build_context(args: List[str], attributes: Type[Attributes]) -> Tuple[Certor
         Util.safe_create_dir(Util.get_build_dir())
         logging_manager = LoggingManager()
 
-    Ctx.handle_flags_in_args(args)
-    context = Ctx.get_args(args)  # Parse arguments
+    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),
@@ -156,11 +156,13 @@ def ensure_version_compatibility(context: CertoraContext) -> None:
         """
         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:
+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:
@@ -187,7 +189,7 @@ def run_local(context: CertoraContext, timings: Dict, additional_commands: Optio
 
     if rc == 0:
         Util.print_completion_message("Finished running verifier:")
-        print("\t%s", " ".join(cmd))
+        print(f'\t{" ".join(cmd)}')
         timings.setdefault("buildTime", 0.0)  # ensure key exists
         return 0
 

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,14 +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
+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:])

certora_cli/certoraRanger.py

@@ -21,7 +21,7 @@ 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
+import CertoraProver.certoraApp as App
 from certoraRun import run_certora
 from Shared.proverCommon import CertoraRunResult, catch_exits
 
@@ -29,7 +29,7 @@ from typing import List, Optional
 
 
 def run_ranger(args: List[str]) -> Optional[CertoraRunResult]:
-    return run_certora(args, Attrs.RangerAttributes, prover_cmd=sys.argv[0])
+    return run_certora(args, App.RangerApp, prover_cmd=sys.argv[0])
 
 @catch_exits
 def entry_point() -> None: