certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 8.5.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

@@ -41,6 +41,46 @@ class MutateValidator:
         self.validate_arg_types()
         self.validate_gambit_objs()
         self.validate_attribute_combinations()
+        self.validate_manual_mutation()
+
+    def validate_manual_mutation(self) -> None:
+        if self.mutate_app.manual_mutants:
+            if not isinstance(self.mutate_app.manual_mutants, list):
+                raise Util.CertoraUserInputError("manual_mutants should be a list of objects")
+            for mutant in self.mutate_app.manual_mutants:
+                if not isinstance(mutant, dict):
+                    raise Util.CertoraUserInputError(f"manual_mutants should be a list of objects, "
+                                                     f"but found {type(mutant)} instead")
+
+                mandatory_keys = {Constants.FILE_TO_MUTATE, Constants.MUTANTS_LOCATION}
+                mutant_keys = set(mutant.keys())
+
+                missing_keys = mandatory_keys - mutant_keys
+                extra_keys = mutant_keys - mandatory_keys
+
+                if missing_keys:
+                    raise Util.CertoraUserInputError(f"manual_mutants object must contain keys: {mandatory_keys}, "
+                                                     f"missing: {missing_keys}")
+                if extra_keys:
+                    raise Util.CertoraUserInputError(f"manual_mutants object contains invalid keys: {extra_keys}, "
+                                                     f"only allowed: {mandatory_keys}")
+                try:
+                    Vf.validate_readable_file(mutant[Constants.FILE_TO_MUTATE], Util.SOL_EXT)
+                except Exception as e:
+                    raise Util.CertoraUserInputError(f"Invalid file_to_mutate in manual mutant: {mutant[Constants.FILE_TO_MUTATE]}", e)
+
+                mutants_location = mutant[Constants.MUTANTS_LOCATION]
+                if Path(mutants_location).is_dir():
+                    try:
+                        Vf.validate_dir(mutants_location)
+                    except Exception as e:
+                        raise Util.CertoraUserInputError(f"Invalid directory for mutants location {mutants_location}",
+                                                         e)
+                else:
+                    try:
+                        Vf.validate_readable_file(mutants_location, Util.SOL_EXT)
+                    except Exception as e:
+                        raise Util.CertoraUserInputError(f"Invalid file for mutants location {mutants_location}", e)
 
     def mutation_attribute_in_prover(self) -> None:
         gambit_attrs = ['filename', 'contract', 'functions', 'seed', 'num_mutants']
@@ -118,8 +158,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,7 +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"
@@ -188,8 +193,19 @@ 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]:
+        """
+        This function is used to hide attributes from the help message.
+        :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

@@ -14,9 +14,10 @@
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import csv
-import fnmatch
 import json
 import os
+import io
+import secrets
 import subprocess
 from abc import ABCMeta
 from enum import Enum, unique, auto
@@ -31,15 +32,15 @@ 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))
 from contextlib import contextmanager
 from Shared.ExpectedComparator import ExpectedComparator
 import logging
-import random
 import time
 import tempfile
 from datetime import datetime
@@ -91,13 +92,14 @@ 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")
 CERTORA_SOURCES = Path(".certora_sources")
-SOLANA_DEFAULT_COMMAND = "cargo +solana build-sbf"
 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'
@@ -115,13 +117,17 @@ 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'
 SUPPRESS_HELP_MSG = "==SUPPRESS=="
 MAX_FLAG_LENGTH = 31
 HELP_TABLE_WIDTH = 97
+DEFAULT_RANGER_RANGE = '5'
+DEFAULT_RANGER_LOOP_ITER = '3'
+DEFAULT_RANGER_FAILURE_LIMIT = '1'
 
 T = TypeVar('T')
 
@@ -151,7 +157,7 @@ def get_build_dir() -> Path:
 
 def get_random_build_dir() -> Path:
     for tries in range(3):
-        build_uuid = f"{datetime.now().strftime('%y_%m_%d_%H_%M_%S')}_{random.randint(0, 999):03d}"
+        build_uuid = f"{datetime.now().strftime('%y_%m_%d_%H_%M_%S')}_{secrets.randbelow(1_000_000):06d}{secrets.token_hex(2)}"
         build_dir = CERTORA_INTERNAL_ROOT / Path(build_uuid)
         if not build_dir.exists():
             return build_dir
@@ -259,6 +265,8 @@ def get_debug_log_file() -> Path:
 def get_extension_info_file() -> Path:
     return path_in_build_directory(Path(".vscode_extension_info.json"))
 
+def get_asts_file() -> Path:
+    return path_in_build_directory(Path(".asts.json"))
 
 def get_zip_output_url_file() -> Path:
     return CERTORA_INTERNAL_ROOT / '.zip-output-url.txt'
@@ -296,8 +304,12 @@ class ImplementationError(Exception):
 class BadMutationError(Exception):
     pass
 
+class ExitException(Exception):
+    def __init__(self, message: str, exit_code: int):
+        super().__init__(message)
+        self.exit_code = exit_code  # Store the integer data
 
-MIN_JAVA_VERSION = 11  # minimal java version to run the local type checker jar
+MIN_JAVA_VERSION = 19  # minimal java version to run the local type checker jar
 
 
 def text_style(txt: str, style: str) -> str:
@@ -362,11 +374,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:
     """
@@ -507,6 +516,18 @@ def safe_copy_folder(source: Path, dest: Path, ignore_patterns: Callable[[str, L
     shutil.rmtree(copy_temp, ignore_errors=True)
 
 
+def safe_merge_folder(source: Path, dest: Path, ignore_patterns: Callable[[str, List[str]], Iterable[str]]) -> None:
+    """
+    Safely merge source to dest. dest may exist. Will overwrite existing files
+    On certain OS/kernels/FS, copying a folder f into a subdirectory of f will
+    send copy tree into an infinite loop. This sidesteps the problem by first copying through a temporary folder.
+    """
+    copy_temp = tempfile.mkdtemp()
+    shutil.copytree(source, copy_temp, ignore=ignore_patterns, dirs_exist_ok=True)
+    shutil.copytree(copy_temp, dest, dirs_exist_ok=True)
+    shutil.rmtree(copy_temp, ignore_errors=True)
+
+
 def as_posix(path: str) -> str:
     """
     Converts path from windows to unix
@@ -953,18 +974,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
@@ -976,7 +985,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)
@@ -991,31 +1000,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
 
 
@@ -1165,26 +1189,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,
@@ -1256,7 +1263,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()
@@ -1269,6 +1276,9 @@ class TestValue(NoValEnum):
     AFTER_GENERATE_COLLECT_REPORT = auto()
     AFTER_BUILD_RUST = auto()
     AFTER_RULE_SPLIT = auto()
+    SOLANA_BUILD_CMD = auto()
+    CHECK_ZIP = auto()
+    STORAGE_EXTENSION_LAYOUT = auto()
 
 class FeValue(NoValEnum):
     PRODUCTION = auto()
@@ -1357,25 +1367,80 @@ 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'):
+            key, value = line.split('=', 1)
+            if key and value:
+                remappings.append(line.strip())
+                for suffix in ['contracts/', 'src/']:
+                    if value.endswith(suffix) and not key.endswith(suffix):
+                        new_remapping = f"{key}{suffix}={value}"
+                        if new_remapping not in remappings:
+                            remappings.append(new_remapping)
+
+    return remappings
+
+def check_remapping_file() -> None:
+    seen: Dict[str, str] = {}
+
+    if not REMAPPINGS_FILE.exists():
+        return
+    with open(REMAPPINGS_FILE) as f:
+        for lineno, line in enumerate(f, 1):
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            parts = line.split("=")
+            if len(parts) != 2:
+                raise CertoraUserInputError(f"Invalid remapping in {REMAPPINGS_FILE}  line {lineno}: {line}")
+            key, value = map(str.strip, parts)
+
+            if key in seen:
+                if seen[key] == value:
+                    io_logger.warning(f"Warning: duplicate key-value pair at line {lineno}: {key}={value}")
+                else:
+                    raise CertoraUserInputError(f"Conflicting values in {REMAPPINGS_FILE} for key '{key}' "
+                                                f"at line {lineno} (previous: '{seen[key]}', new: '{value}')")
+            else:
+                seen[key] = value
+
 
 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 = []
+    check_remapping_file()
+    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
+                remappings_set = set(filter(lambda x: x != "", map(lambda x: x.strip(), remappings_file.readlines())))
+            remappings = list(remappings_set)
         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()
+
+    context.forge_remappings = remappings
+
+    return remappings
 
 
 def get_ir_flag(solc: str) -> str:
@@ -1443,3 +1508,58 @@ 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_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 / 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()
+    parent_dir = get_certora_sources_dir().absolute()
+
+    try:
+        file_path.relative_to(parent_dir)
+        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