certora-cli-beta-mirror 7.30.1__py3-none-any.whl → 8.0.0__py3-none-any.whl

certora_cli/Shared/certoraUtils.py

@@ -14,7 +14,6 @@
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import csv
-import fnmatch
 import json
 import os
 import subprocess
@@ -97,6 +96,7 @@ EMV_JAR = Path("emv.jar")
 CERTORA_SOURCES = Path(".certora_sources")
 SOLANA_INLINING = "solana_inlining"
 SOLANA_SUMMARIES = "solana_summaries"
+CARGO_TOML_FILE = "cargo.toml"
 
 ALPHA_PACKAGE_NAME = 'certora-cli-alpha'
 ALPHA_PACKAGE_MASTER_NAME = ALPHA_PACKAGE_NAME + '-master'
@@ -114,7 +114,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 +369,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 +957,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 +968,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 +983,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
 
 
@@ -1171,26 +1172,9 @@ class Singleton(type):
             cls.__instancesinstances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
         return cls.__instancesinstances[cls]
 
-
 class AbstractAndSingleton(Singleton, ABCMeta):
     pass
 
-
-def match_path_to_mapping_key(path: Path, m: Dict[str, str]) -> Optional[str]:
-    """
-    Matches the path to the best match in the dictionary's keys.
-    For example, given an absolute path `/Users/JohnDoe/Path/ToSolc/a.sol`, if the map contains
-    `b/a.sol` and `ToSolc/a.sol`, it will match on `ToSolc/a.sol`.
-    @param path: the path to match against
-    @param m: the map whose keys we're searching
-    @return: the value from the map that best matches the path, None if not found.
-    """
-    for k, v in m.items():
-        if fnmatch.fnmatch(str(path), k):
-            return v
-    return None
-
-
 def find_in(dir_path: Path, file_to_find: Path) -> Optional[Path]:
     """
     Given a directory dir_path and a file we wish to find within that directory,
@@ -1262,7 +1246,7 @@ class TestValue(NoValEnum):
     determines the chekpoint where the execution will halt. The exception TestResultsReady will be thrown. The value
     will also determine what object will be attached to the exception for inspection by the caller
     """
-    LOCAL_JAR = auto()
+    BEFORE_LOCAL_PROVER_CALL = auto()
     CHECK_ARGS = auto()
     AFTER_BUILD = auto()
     CHECK_SOLC_OPTIONS = auto()
@@ -1452,3 +1436,22 @@ def eq_by(f: Callable[[T, T], bool], a: Sequence[T], b: Sequence[T]) -> bool:
     check if Sequences a and b are equal according to function f.
     """
     return len(a) == len(b) and all(map(f, a, b))
+
+def find_nearest_cargo_toml() -> Optional[Path]:
+    current = Path.cwd()
+    for parent in [current] + list(current.parents):
+        candidate = parent / CARGO_TOML_FILE
+        if candidate.is_file():
+            return candidate
+    return None
+
+def file_in_source_tree(file_path: Path) -> bool:
+    # if the file is under .certora_source, return True
+    file_path = Path(file_path).absolute()
+    parent_dir = get_certora_sources_dir().absolute()
+
+    try:
+        file_path.relative_to(parent_dir)
+        return True
+    except ValueError:
+        return False

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,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(
@@ -684,7 +684,7 @@ def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
         if first:
             validation_logger.warning("all via_ir values are set to True '--solc_via_ir' 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("all via_ir values are set to False, this flag/attribute can be omitted")
 
 def validate_solc_evm_version_map(args: Dict[str, str]) -> None:
     if not isinstance(args, dict):
@@ -758,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('.')
@@ -938,7 +948,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
@@ -971,7 +981,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('=')
@@ -993,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

@@ -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:
@@ -176,6 +178,8 @@ def run_local(context: CertoraContext, timings: Dict, additional_commands: Optio
         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,
@@ -185,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.certoraContextAttributes as Attrs
+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, Attrs.ConcordAttributes, prover_cmd=sys.argv[0])
+
+@catch_exits
+def entry_point() -> None:
+    run_concord(sys.argv[1:])
+
+if __name__ == '__main__':
+    entry_point()

certora_cli/certoraRun.py

@@ -24,10 +24,9 @@ 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.certoraCloudIO import CloudVerification
 
 from CertoraProver.certoraBuild import build
-from CertoraProver.certoraBuildRust import set_rust_build_directory
 import CertoraProver.certoraContext as Ctx
 
 from CertoraProver import certoraContextValidator as Cv
@@ -52,7 +51,7 @@ BUILD_SCRIPT_PATH = Path("CertoraProver/certoraBuild.py")
 # 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,
+def run_certora(args: List[str], attrs_class: Type[AttrUtil.Attributes] = Attrs.EvmProverAttributes,
                 prover_cmd: Optional[str] = None) -> Optional[CertoraRunResult]:
     """
     The main function that is responsible for the general flow of the script.
@@ -61,9 +60,6 @@ def run_certora(args: List[str], attrs_class: Optional[Type[AttrUtil.Attributes]
     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:
@@ -78,7 +74,7 @@ def run_certora(args: List[str], attrs_class: Optional[Type[AttrUtil.Attributes]
     # Collect and dump configuration layout
     collect_and_dump_config_layout(context)
 
-    if Attrs.is_evm_app() and context.split_rules:
+    if context.split_rules:
         context.build_only = True
         build(context)
         context.build_only = False
@@ -90,94 +86,60 @@ def run_certora(args: List[str], attrs_class: Optional[Type[AttrUtil.Attributes]
         else:
             raise Util.ExitException("Split rules failed", exit_code)
 
-    if Attrs.is_rust_app():
-        set_rust_build_directory(context)
+    # Version validation
+    ensure_version_compatibility(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)
+    # 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()
 
-            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 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:
-
-        # 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)
+    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)

certora_cli/certoraSolanaProver.py

@@ -25,7 +25,7 @@ sys.path.insert(0, str(scripts_dir_path))
 
 
 import CertoraProver.certoraContextAttributes as Attrs
-from Shared.rustProverCommon import build_rust_project
+from CertoraProver.certoraBuildRust import build_rust_project
 from Shared.proverCommon import (
     build_context,
     collect_and_dump_metadata,

certora_cli/certoraSorobanProver.py

@@ -26,7 +26,7 @@ from typing import List, Optional, Dict
 
 import CertoraProver.certoraContextAttributes as Attrs
 
-from Shared.rustProverCommon import build_rust_project
+from CertoraProver.certoraBuildRust import build_rust_project
 from Shared.proverCommon import (
     build_context,
     collect_and_dump_metadata,