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

certora_cli/CertoraProver/certoraBuildCacheManager.py

@@ -66,10 +66,9 @@ class CertoraBuildCacheManager:
         @returns None if no cache hit, otherwise - the matching `.certora_build.json` file, and a set of source files
         """
         build_cache_dir = Util.get_certora_build_cache_dir()
-        main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
-        main_cache_entry_dir = build_cache_dir / main_cache_key
+        main_cache_entry_dir = build_cache_dir / context.main_cache_key
         if not main_cache_entry_dir.exists():
-            build_cache_logger.info(f"cache miss on build cache key {main_cache_key}")
+            build_cache_logger.info(f"cache miss on build cache key {context.main_cache_key}")
             return None
 
         # here's the tricky matching part:
@@ -92,7 +91,7 @@ class CertoraBuildCacheManager:
                     build_cache_logger.debug(f"Current sub build cache key computed for {file_list_file} is invalid")
                     continue
                 elif sub_cache_key_current_for_list == sub_cache_key_from_saved_entry:
-                    build_cache_logger.info(f"We have a match on build cache key {main_cache_key} and "
+                    build_cache_logger.info(f"We have a match on build cache key {context.main_cache_key} and "
                                             f"{sub_cache_key_current_for_list}")
                     sub_cache_key = sub_cache_key_current_for_list
                     all_contract_files = set([Path(f) for f in file_list])
@@ -103,24 +102,24 @@ class CertoraBuildCacheManager:
 
         if sub_cache_key is None:
             build_cache_logger.info("All sub-cache-key file list files missed, cache miss on build cache key "
-                                    f"{main_cache_key}")
+                                    f"{context.main_cache_key}")
             return None
 
         # cache hit
         certora_build_file = main_cache_entry_dir / f"{sub_cache_key}.{CachedFiles.certora_build_suffix}"
         if not certora_build_file.exists():
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and {sub_cache_key} "
                                        "but .certora_build.json file does not exist")
             return None
 
         if all_contract_files is None:  # should not be feasible
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
-                                       "but file list file does not exist")
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and "
+                                       f"{sub_cache_key} but file list file does not exist")
             return None
 
         build_output_props_file = main_cache_entry_dir / f"{sub_cache_key}.{CachedFiles.build_output_props_suffix}"
         if not build_output_props_file.exists():
-            build_cache_logger.warning(f"Got a cache-hit on build cache key {main_cache_key} and {sub_cache_key} "
+            build_cache_logger.warning(f"Got a cache-hit on build cache key {context.main_cache_key} and {sub_cache_key} "
                                        f"but {CachedFiles.build_output_props_suffix} file does not exist")
             return None
 
@@ -131,26 +130,26 @@ class CertoraBuildCacheManager:
     @staticmethod
     def save_build_cache(context: CertoraContext, cached_files: CachedFiles) -> None:
         build_cache_dir = Util.get_certora_build_cache_dir()
-        main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
-        main_cache_entry_dir = build_cache_dir / main_cache_key
+        main_cache_entry_dir = build_cache_dir / context.main_cache_key
         sub_cache_key = CertoraBuildCacheManager.get_sub_cache_key(cached_files.all_contract_files)
         if sub_cache_key is None:
-            build_cache_logger.warning(f"Cannot save cache for main build cache key {main_cache_key} "
+            build_cache_logger.warning(f"Cannot save cache for main build cache key {context.main_cache_key} "
                                        "as sub-cache-key could not be computed")
             return
 
         if main_cache_entry_dir.exists():
-            build_cache_logger.info(f"main build cache key already exists {main_cache_key}, "
+            build_cache_logger.info(f"main build cache key already exists {context.main_cache_key}, "
                                     f"saving sub build cache key {sub_cache_key}")
             if cached_files.all_exist(main_cache_entry_dir, sub_cache_key):
                 build_cache_logger.debug("cache already saved under this build cache key, override")
             else:
-                build_cache_logger.debug(f"cache was corrupted, need to re-save build cache key {main_cache_key} "
-                                         f"and sub cache key {sub_cache_key}")
+                build_cache_logger.debug(f"cache was corrupted, need to re-save build cache key "
+                                         f"{context.main_cache_key} and sub cache key {sub_cache_key}")
             CertoraBuildCacheManager.save_files(cached_files, main_cache_entry_dir,
                                                 sub_cache_key)
         else:
-            build_cache_logger.info(f"saving main build cache key {main_cache_key} and sub cache key {sub_cache_key}")
+            build_cache_logger.info(f"saving main build cache key {context.main_cache_key} and sub cache key "
+                                    f"{sub_cache_key}")
             safe_create_dir(main_cache_entry_dir)
             CertoraBuildCacheManager.save_files(cached_files, main_cache_entry_dir,
                                                 sub_cache_key)
@@ -180,7 +179,12 @@ class CertoraBuildCacheManager:
             trg = trg_path_with_additional_included_files / post_autofinder_dir.name
             if post_autofinder_dir != trg:
                 if post_autofinder_dir.is_dir():
-                    Util.safe_copy_folder(post_autofinder_dir, trg, shutil.ignore_patterns())
+                    # if we match on the cache, and we run a few certoraRun-s in parallel,
+                    # it could be this folder already exists. But the exact contents do not matter and are likely to
+                    # agree with the exception of spec files. So let's merge the folders so that the
+                    # sources are in any case runnable
+                    if not trg.exists():
+                        Util.safe_merge_folder(post_autofinder_dir, trg, shutil.ignore_patterns())
                 else:
                     # highly unlikely .post_autofinder.[digit] will be a file and not a directory,
                     # but would rather not crash and future-proof instead

certora_cli/CertoraProver/certoraBuildDataClasses.py

@@ -107,7 +107,8 @@ class ContractInSDC:
                  extension_contracts: List[ContractExtension],
                  local_assignments: Dict[str, UnspecializedSourceFinder],
                  branches: Dict[str, UnspecializedSourceFinder],
-                 requires: Dict[str, UnspecializedSourceFinder]
+                 requires: Dict[str, UnspecializedSourceFinder],
+                 internal_starts: List[int]
                  ):
         self.name = name
         self.original_file = source_file
@@ -139,6 +140,7 @@ class ContractInSDC:
         self.original_file_name = Path(source_file).name
         self.compiler_collector = compiler_collector
         self.compiler_parameters = compiler_parameters
+        self.internal_starts = internal_starts
 
         if not self.compiler_collector:
             compiler_version = ""
@@ -161,6 +163,7 @@ class ContractInSDC:
         self.local_assignments = local_assignments
         self.branches = branches
         self.requires = requires
+        self.internal_function_harnesses: Dict[str, str] = {}
 
     def as_dict(self) -> Dict[str, Any]:
         """
@@ -186,6 +189,7 @@ class ContractInSDC:
             # why are we using this and not the normal list of functions?
             "internalFunctions": {key: method.as_dict() for key, method in self.function_finders.items()},
             # this doesn't even have all functions
+            "internalFuncs": [f.as_dict() for f in self.internal_funcs],
             "allMethods": [f.as_dict() for f in self.all_funcs],
             "solidityTypes": [x.as_dict() for x in self.types],
             "compilerName": "" if not self.compiler_collector else self.compiler_collector.compiler_name,
@@ -193,7 +197,9 @@ class ContractInSDC:
             "compilerParameters": None if not self.compiler_parameters else self.compiler_parameters.as_dict(),
             "sourceBytes": None if self.source_bytes is None else self.source_bytes.as_dict(),
             "extensionContracts": [e.as_dict() for e in self.extension_contracts],
-            "localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()}
+            "localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()},
+            "internalFunctionStarts": self.internal_starts,
+            "internalFunctionHarnesses": self.internal_function_harnesses
         }
         # "sourceHints": {"localAssignments": {k: v.as_dict() for k, v in self.local_assignments.items()},
         #                 "branches": {k: v.as_dict() for k, v in self.branches.items()},

certora_cli/CertoraProver/certoraBuildRust.py

@@ -13,58 +13,97 @@
 #     You should have received a copy of the GNU General Public License
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+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 glob
 import shutil
+import time
+import logging
 from pathlib import Path
-from typing import Set
+from typing import Set, Dict
 
 from CertoraProver.certoraBuild import build_source_tree
 from CertoraProver.certoraContextClass import CertoraContext
-from CertoraProver.certoraParseBuildScript import run_script_and_parse_json
+from CertoraProver.certoraParseBuildScript import run_rust_build
 import CertoraProver.certoraContextAttributes as Attrs
 from Shared import certoraUtils as Util
 
 
-def build_rust_app(context: CertoraContext) -> None:
-    if context.build_script:
-        run_script_and_parse_json(context)
-        if not context.rust_executables:
-            raise Util.CertoraUserInputError("failed to get target executable")
+log = logging.getLogger(__name__)
+
 
-        sources: Set[Path] = set()
-        collect_files_from_rust_sources(context, sources)
+def build_rust_project(context: CertoraContext, timings: Dict) -> None:
+    """
+    Compile the Rust artefact and record elapsed time in *timings*.
 
-        try:
-            # Create generators
-            build_source_tree(sources, context)
+    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)
 
-            copy_files_to_build_dir(context)
 
-        except Exception as e:
-            raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
-    else:
-        if not context.files:
-            raise Util.CertoraUserInputError("'files' or 'build_script' must be set for Rust projects")
-        if len(context.files) > 1:
-            raise Util.CertoraUserInputError("Rust projects must specify exactly one executable in 'files'.")
+def set_rust_build_directory(context: CertoraContext) -> None:
+    if not context.files:
+        build_rust_app(context)
 
-        try:
-            Util.get_certora_sources_dir().mkdir(parents=True, exist_ok=True)
-            shutil.copy(Util.get_last_conf_file(), Util.get_certora_sources_dir() / Util.LAST_CONF_FILE)
-        except Exception as e:
-            raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+    copy_files_to_build_dir(context)
 
-        context.rust_executables = context.files[0]
+    sources: Set[Path] = set()
+    collect_files_from_rust_sources(context, sources)
 
+    try:
+        # Create generators
+        build_source_tree(sources, context)
 
-def add_solana_files(context: CertoraContext, sources: Set[Path]) -> None:
-    for attr in [Attrs.SolanaProverAttributes.SOLANA_INLINING, Attrs.SolanaProverAttributes.SOLANA_SUMMARIES]:
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+
+
+def build_rust_app(context: CertoraContext) -> None:
+    assert not context.files, "build_rust_app: expecting files to be empty"
+    if context.build_script:
+        build_command = [context.build_script, '--json', '-l']
+        feature_flag = '--cargo_features'
+    else:  # cargo
+        build_command = ["cargo", "certora-sbf", '--json']
+        feature_flag = '--features'
+        if context.cargo_tools_version:
+            build_command.extend(["--tools-version", context.cargo_tools_version])
+        context.rust_project_directory = Util.find_nearest_cargo_toml()
+
+    if context.cargo_features is not None:
+        build_command.append(feature_flag)
+        build_command.append(' '.join(context.cargo_features))
+
+    if context.test == str(Util.TestValue.SOLANA_BUILD_CMD):
+        raise Util.TestResultsReady(build_command)
+
+    run_rust_build(context, build_command)
+
+
+def add_solana_files_to_sources(context: CertoraContext, sources: Set[Path]) -> None:
+    for attr in [Attrs.SolanaProverAttributes.SOLANA_INLINING,
+                 Attrs.SolanaProverAttributes.SOLANA_SUMMARIES,
+                 Attrs.SolanaProverAttributes.BUILD_SCRIPT,
+                 Attrs.SolanaProverAttributes.FILES]:
         attr_name = attr.get_conf_key()
         attr_value = getattr(context, attr_name, None)
         if not attr_value:
             continue
         if isinstance(attr_value, str):
-            attr_value = [str]
+            attr_value = [attr_value]
         if not isinstance(attr_value, list):
             raise Util.CertoraUserInputError(f"{attr_value} is not a valid value for {attr_name} {attr_value}. Value "
                                              f"must be a string or a llist ")
@@ -72,44 +111,39 @@ def add_solana_files(context: CertoraContext, sources: Set[Path]) -> None:
         for file_path in file_paths:
             if not file_path.exists():
                 raise Util.CertoraUserInputError(f"in {attr_name} file {file_path} does not exist")
-            sources.add(file_path.absolute())
+            sources.add(file_path.absolute().resolve())
 
 
 def collect_files_from_rust_sources(context: CertoraContext, sources: Set[Path]) -> None:
-    patterns = ["*.rs", "*.so", "*.wasm", "Cargo.toml", "Cargo.lock", "justfile"]
+    patterns = ["*.rs", "*.so", "*.wasm", Util.CARGO_TOML_FILE, "Cargo.lock", "justfile"]
     exclude_dirs = [".certora_internal"]
 
-    root_directory = Path(context.rust_project_directory)
+    if hasattr(context, 'rust_project_directory'):
+        project_directory = Path(context.rust_project_directory)
 
-    if not root_directory.is_dir():
-        raise ValueError(f"The given directory '{root_directory}' is not valid.")
+        if not project_directory.is_dir():
+            raise ValueError(f"The given directory '{project_directory}' is not valid.")
 
-    for source in context.rust_sources:
-        for file in glob.glob(f'{root_directory.joinpath(source)}', recursive=True):
-            file_path = Path(file)
-            if any(excluded in file_path.parts for excluded in exclude_dirs):
-                continue
-            if file_path.is_file() and any(file_path.match(pattern) for pattern in patterns):
-                sources.add(file_path)
+        for source in context.rust_sources:
+            for file in glob.glob(f'{project_directory.joinpath(source)}', recursive=True):
+                file_path = Path(file)
+                if any(excluded in file_path.parts for excluded in exclude_dirs):
+                    continue
+                if file_path.is_file() and any(file_path.match(pattern) for pattern in patterns):
+                    sources.add(file_path)
 
-    sources.add(Path(context.rust_project_directory).absolute())
-    if Path(context.build_script).exists():
-        sources.add(Path(context.build_script).resolve())
+        sources.add(project_directory.absolute())
+        if context.build_script:
+            sources.add(Path(context.build_script).resolve())
     if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
         sources.add(Path(context.conf_file).absolute())
-    add_solana_files(context, sources)
 
+    add_solana_files_to_sources(context, sources)
 
-def copy_files_to_build_dir(context: CertoraContext) -> None:
-    rust_executable = Path(context.rust_project_directory) / context.rust_executables
-    shutil.copyfile(rust_executable, Util.get_build_dir() / rust_executable.name)
-
-    additional_files = (getattr(context, 'solana_inlining', None) or []) + \
-                       (getattr(context, 'solana_summaries', None) or [])
 
-    for file in additional_files:
-        file_path = Path(file).resolve()
-        shutil.copy(file_path, Util.get_build_dir() / file_path.name)
+def copy_files_to_build_dir(context: CertoraContext) -> None:
+    assert context.files, "copy_files_to_build_dir: expecting files to be non-empty"
+    shutil.copyfile(context.files[0], Util.get_build_dir() / Path(context.files[0]).name)
 
     if rust_logs := getattr(context, 'rust_logs_stdout', None):
         shutil.copy(Path(rust_logs), Util.get_build_dir() / Path(rust_logs).name)

certora_cli/CertoraProver/certoraBuildSui.py

@@ -0,0 +1,112 @@
+#     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/>.
+
+from __future__ import annotations
+
+import subprocess
+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 shutil
+import time
+import logging
+from pathlib import Path
+from typing import Set, Dict
+
+from CertoraProver.certoraBuild import build_source_tree
+from CertoraProver.certoraContextClass import CertoraContext
+from Shared import certoraUtils as Util
+
+
+log = logging.getLogger(__name__)
+
+
+def build_sui_project(context: CertoraContext, timings: Dict) -> None:
+    """
+    Compile the Sui 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 Sui target")
+    start = time.perf_counter()
+    set_sui_build_directory(context)
+    timings["buildTime"] = round(time.perf_counter() - start, 4)
+    if context.test == str(Util.TestValue.AFTER_BUILD):
+        raise Util.TestResultsReady(context)
+
+
+def set_sui_build_directory(context: CertoraContext) -> None:
+    sources: Set[Path] = set()
+
+    # If no move_path was specified, try to build the package
+    if not context.move_path:
+        move_toml_file = Util.find_file_in_parents("Move.toml")
+        if not move_toml_file:
+            raise Util.CertoraUserInputError("Could not find Move.toml, and no move_path was specified.")
+        sources.add(move_toml_file.absolute())
+        run_sui_build(context, move_toml_file.parent)
+
+    assert context.move_path, "expecting move_path to be set after build"
+    move_dir = Path(context.move_path)
+    assert move_dir.exists(), f"Output path '{move_dir}' does not exist"
+    assert move_dir.is_dir(), f"Output path '{move_dir}' is not a directory"
+
+    # Add all source files.  We get these from the Sui build output, because it includes dependencies as well, and is
+    # available even if we didn't run the build ourselves.
+    sources.update(move_dir.rglob("*.move"))
+
+    # Add conf file if it exists
+    if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
+        sources.add(Path(context.conf_file).absolute())
+
+    # Copy the binary modules and source maps
+    shutil.copytree(move_dir,
+                    Util.get_build_dir() / move_dir.name,
+                    ignore=shutil.ignore_patterns('*.move'))
+
+    try:
+        # Create generators
+        build_source_tree(sources, context)
+
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+
+def run_sui_build(context: CertoraContext, package_dir: Path) -> None:
+    assert not context.move_path, "run_sui_build: expecting move_path to be empty"
+
+    build_cmd = ["sui", "move", "build", "--test", "--path", str(package_dir)]
+
+    try:
+        build_cmd_text = ' '.join(build_cmd)
+        log.info(f"Building by calling `{build_cmd_text}`")
+        result = subprocess.run(build_cmd, capture_output=False)
+
+        # Check if the script executed successfully
+        if result.returncode != 0:
+            raise Util.CertoraUserInputError(f"Error running `{build_cmd_text}`")
+
+        context.move_path = str(package_dir / "build")
+
+    except Util.TestResultsReady as e:
+        raise e
+    except Util.CertoraUserInputError as e:
+        raise e
+    except Exception as e:
+        raise Util.CertoraUserInputError(f"An unexpected error occurred: {e}")