certora-cli-alpha-master 20250520.21.30.33372__tar.gz → 20250521.12.50.829403__tar.gz

{certora_cli_alpha_master-20250520.21.30.33372/certora_cli_alpha_master.egg-info → certora_cli_alpha_master-20250521.12.50.829403}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli-alpha-master
-Version: 20250520.21.30.33372
+Version: 20250521.12.50.829403
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-alpha-master
 Author: Certora
@@ -37,4 +37,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 0b54154.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 0cdebd6.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli_alpha_master-20250521.12.50.829403/README.md

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

{certora_cli_alpha_master-20250520.21.30.33372 → certora_cli_alpha_master-20250521.12.50.829403}/certora_cli/Mutate/mutateApp.py

@@ -44,7 +44,9 @@ from CertoraProver.certoraContextValidator import KEY_ENV_VAR
 from Mutate import mutateConstants as MConstants
 from Shared import certoraUtils as Util
 from Shared.certoraLogging import LoggingManager
-from certoraRun import run_certora, CertoraRunResult, CertoraFoundViolations
+from certoraRun import run_certora
+from Shared.proverCommon import CertoraRunResult, CertoraFoundViolations
+from certoraSorobanProver import run_soroban_prover
 from Shared import certoraValidateFuncs as Vf
 from CertoraProver.Compiler.CompilerCollectorFactory import get_relevant_compiler
 from Mutate import mutateUtil as MutUtil
@@ -1416,7 +1418,10 @@ class MutateApp:
             certora_args.extend(["--disable_local_typechecking"])
         mutation_logger.debug(f"Running the Prover: {certora_args}")
         try:
-            certora_run_result = run_certora(certora_args)
+            if self.is_soroban_run():
+                certora_run_result = run_soroban_prover(certora_args)
+            else:
+                certora_run_result = run_certora(certora_args)
         except CertoraFoundViolations as e:
             assert e.results, "expect e.results not to be None"
             certora_run_result = e.results

certora_cli_alpha_master-20250521.12.50.829403/certora_cli/Shared/proverCommon.py

@@ -0,0 +1,300 @@
+#     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
+
+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
+from Shared.certoraAttrUtil import Attributes
+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
+
+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], attributes: Type[Attributes]) -> 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.
+        attributes: The attributes class to use for the context. (e.g., SolanaProverAttributes or SorobanProverAttributes)
+    Returns:
+        A tuple containing the CertoraContext object and the LoggingManager object.
+    """
+    Attrs.set_attribute_class(attributes)
+    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)
+    context = Ctx.get_args(args)  # 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("Verifier run command:\n %s", " ".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("\t%s", " ".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}")
+            sys.exit(1)
+
+    return wrapper

certora_cli_alpha_master-20250521.12.50.829403/certora_cli/Shared/rustProverCommon.py

@@ -0,0 +1,62 @@
+#     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 Rust-based targets (Solana & Soroban).
+
+Placing the build  logic in one module removes
+duplication from the dedicated entry scripts.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+import time
+import logging
+from typing import Dict
+
+from Shared import certoraUtils as Util
+
+from CertoraProver.certoraContextClass import CertoraContext
+
+from CertoraProver.certoraBuildRust import set_rust_build_directory
+
+
+log = logging.getLogger(__name__)
+
+
+# --------------------------------------------------------------------------- #
+# Build
+# --------------------------------------------------------------------------- #
+
+def build_rust_project(context: CertoraContext, timings: Dict) -> None:
+    """
+    Compile the Rust artefact and record elapsed time in *timings*.
+
+    Args:
+        context: The CertoraContext object containing the configuration.
+        timings: A dictionary to store timing information.
+    """
+    log.debug("Build Rust target")
+    start = time.perf_counter()
+    set_rust_build_directory(context)
+    timings["buildTime"] = round(time.perf_counter() - start, 4)
+    if context.test == str(Util.TestValue.AFTER_BUILD):
+        raise Util.TestResultsReady(context)

{certora_cli_alpha_master-20250520.21.30.33372 → certora_cli_alpha_master-20250521.12.50.829403}/certora_cli/certoraEVMProver.py

@@ -22,7 +22,8 @@ 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
+from Shared.proverCommon import CertoraRunResult
+from certoraRun import run_certora
 from typing import List, Optional
 
 

certora_cli_alpha_master-20250521.12.50.829403/certora_cli/certoraRanger.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.certoraContextAttributes as Attrs
+from certoraRun import run_certora
+from Shared.proverCommon import CertoraRunResult, catch_exits
+
+from typing import List, Optional
+
+
+def run_ranger(args: List[str]) -> Optional[CertoraRunResult]:
+    return run_certora(args, Attrs.RangerAttributes, prover_cmd=sys.argv[0])
+
+@catch_exits
+def entry_point() -> None:
+    run_ranger(sys.argv[1:])
+
+if __name__ == '__main__':
+    entry_point()

certora_cli_alpha_master-20250521.12.50.829403/certora_cli/certoraRun.py

@@ -0,0 +1,216 @@
+#!/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
+import time
+import logging
+from typing import List, Optional, Type
+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 CertoraProver.certoraCloudIO import CloudVerification, validate_version_and_branch
+
+from CertoraProver.certoraBuild import build
+from CertoraProver.certoraBuildRust import set_rust_build_directory
+import CertoraProver.certoraContext as Ctx
+
+from CertoraProver import certoraContextValidator as Cv
+import CertoraProver.certoraContextAttributes as Attrs
+from Shared import certoraAttrUtil as AttrUtil
+from Shared.proverCommon import (
+    build_context,
+    collect_and_dump_metadata,
+    collect_and_dump_config_layout,
+    ensure_version_compatibility,
+    run_local,
+    run_remote,
+    CertoraRunResult,
+    handle_exit,
+    catch_exits
+)
+import CertoraProver.splitRules as splitRules
+
+BUILD_SCRIPT_PATH = Path("CertoraProver/certoraBuild.py")
+
+# logger for issues regarding the general run flow.
+# Also serves as the default logger for errors originating from unexpected places.
+run_logger = logging.getLogger("run")
+
+def run_certora(args: List[str], attrs_class: Optional[Type[AttrUtil.Attributes]] = None,
+                prover_cmd: Optional[str] = None) -> Optional[CertoraRunResult]:
+    """
+    The main function that is responsible for the general flow of the script.
+    The general flow is:
+    1. Parse program arguments
+    2. Run the necessary steps (type checking/ build/ cloud verification/ local verification)
+
+    """
+    if not attrs_class:
+        attrs_class = Attrs.detect_application_class(args)
+
+    context, logging_manager = build_context(args, attrs_class)
+
+    if prover_cmd:
+        context.prover_cmd = prover_cmd
+
+    timings = {}
+    exit_code = 0  # The exit code of the script. 0 means success, any other number is an error.
+    return_value = None
+
+    # Collect and validate metadata
+    collect_and_dump_metadata(context)
+    # Collect and dump configuration layout
+    collect_and_dump_config_layout(context)
+
+    if Attrs.is_evm_app() and context.split_rules:
+        context.build_only = True
+        build(context)
+        context.build_only = False
+        rule_handler = splitRules.SplitRulesHandler(context)
+        exit_code = rule_handler.generate_runs()
+        CloudVerification(context).print_group_id_url()
+        if exit_code == 0:
+            print("Split rules succeeded")
+        else:
+            raise Util.ExitException("Split rules failed", exit_code)
+
+    if Attrs.is_rust_app():
+        set_rust_build_directory(context)
+
+        if context.local:
+            check_cmd = Ctx.get_local_run_cmd(context)
+            check_cmd_string = " ".join(check_cmd)
+            print(f"Verifier run command:\n {check_cmd_string}", flush=True)
+
+            compare_with_tool_output = False
+            run_result = Util.run_jar_cmd(check_cmd, compare_with_tool_output, logger_topic="verification",
+                                          print_output=True)
+            # For solana and wasm, we don't check types so build time is zero.
+            timings["buildTime"] = 0.0
+            if run_result != 0:
+                exit_code = 1
+            else:
+                Util.print_completion_message("Finished running verifier:")
+                print(f"\t{check_cmd_string}")
+        else:
+            validate_version_and_branch(context)
+            context.key = Cv.validate_certora_key()
+            cloud_verifier = CloudVerification(context, timings)
+            # Wrap strings with space with ' so it can be copied and pasted to shell
+            pretty_args = [f"'{arg}'" if ' ' in arg else arg for arg in args]
+            cl_args = ' '.join(pretty_args)
+            logging_manager.remove_debug_logger()
+            result = cloud_verifier.cli_verify_and_report(cl_args, context.wait_for_results)
+            if cloud_verifier.statusUrl:
+                return_value = CertoraRunResult(cloud_verifier.statusUrl, False,
+                                                Util.get_certora_sources_dir(), cloud_verifier.reportUrl)
+            if not result:
+                exit_code = 1
+    else:
+
+        # Version validation
+        ensure_version_compatibility(context)
+
+        # When a TAC file is provided, no build arguments will be processed
+        if not context.is_tac:
+            run_logger.debug(f"There is no TAC file. Going to script {BUILD_SCRIPT_PATH} to main_with_args()")
+            build_start = time.perf_counter()
+
+            # If we are not in CI, we also check the spec for Syntax errors.
+            build(context)
+            build_end = time.perf_counter()
+
+            timings["buildTime"] = round(build_end - build_start, 4)
+            if context.test == str(Util.TestValue.AFTER_BUILD):
+                raise Util.TestResultsReady(context)
+
+        if context.build_only:
+            return return_value
+
+        # either we skipped building (TAC MODE) or build succeeded
+        if context.local:
+            compare_with_expected_file = Path(context.expected_file).exists()
+
+            run_result = run_local(context, timings, compare_with_expected_file=compare_with_expected_file)
+            emv_dir = latest_emv_dir()
+            return_value = CertoraRunResult(str(emv_dir) if emv_dir else None, True,
+                                            Util.get_certora_sources_dir(), None)
+            if run_result != 0:
+                exit_code = run_result
+            elif compare_with_expected_file:
+                print("Comparing tool output to the expected output:")
+                output_path = context.tool_output or (
+                    'tmpOutput.json' if emv_dir is None else
+                    str(emv_dir / 'Reports/output.json')
+                )
+                result = Util.check_results_from_file(output_path, context.expected_file)
+                if not result:
+                    exit_code = 1
+        else:  # Remote run
+            # Syntax checking and typechecking
+            if Cv.mode_has_spec_file(context):
+                if context.disable_local_typechecking:
+                    run_logger.warning(
+                        "Local checks of CVL specification files disabled. It is recommended to enable "
+                        "the checks.")
+                else:
+                    typechecking_start = time.perf_counter()
+                    Ctx.run_local_spec_check(True, context)
+                    typechecking_end = time.perf_counter()
+                    timings['typecheckingTime'] = round(typechecking_end - typechecking_start, 4)
+
+            # Remove debug logger and run remote verification
+            logging_manager.remove_debug_logger()
+            exit_code, return_value = run_remote(context, args, timings)
+
+    # Handle exit codes and return
+    return handle_exit(exit_code, return_value)
+
+
+def latest_emv_dir() -> Optional[Path]:
+    """
+    Returns the latest emv-... directory.
+    This is known to be highly unreliable _unless_ we know that in the current work dir only one jar
+    is invoked every time, and that we do not pass arguments to the jar that change the output directory.
+    The current use case is for the local-and-sync'd dev-mode for mutation testing.
+    """
+    cwd = Path.cwd()
+    candidates = list(cwd.glob(r"emv-[0-9]*-certora-*"))
+    max = None
+    max_no = -1
+    for candidate in candidates:
+        if candidate.is_dir():
+            index = int(str(candidate.stem).split("-")[1])
+            if index > max_no:
+                max = candidate
+                max_no = index
+    return max
+
+
+@catch_exits
+def entry_point() -> None:
+    """
+    This function is the entry point of the certora_cli customer-facing package, as well as this script.
+    It is important this function gets no arguments!
+    """
+    run_certora(sys.argv[1:], prover_cmd=sys.argv[0])
+
+
+if __name__ == '__main__':
+    entry_point()