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

certora_cli/CertoraProver/splitRules.py

@@ -18,11 +18,14 @@ import sys
 import re
 from pathlib import Path
 import subprocess
+import tempfile
 import uuid
 
 from typing import List, Set, Optional
 
+import CertoraProver.certoraContext as Ctx
 import CertoraProver.certoraContextAttributes as Attrs
+import CertoraProver.certoraApp as App
 from CertoraProver.certoraContextClass import CertoraContext
 from Shared import certoraUtils as Util
 
@@ -71,31 +74,33 @@ class SplitRulesHandler():
         def jar_list_value(list_attr: List[str]) -> str:
             return ','.join(list_attr)
 
-        path_to_typechecker = Util.find_jar("Typechecker.jar")
+        with tempfile.NamedTemporaryFile("r", dir=Util.get_build_dir()) as tmp_file:
+            args = ["-listRules", tmp_file.name]
 
-        command = ["java", "-jar", str(path_to_typechecker), "-listRules", "-buildDirectory", str(Util.get_build_dir())]
+            if self.context.exclude_rule:
+                args += ['-excludeRule', jar_list_value(self.context.exclude_rule)]
 
-        if self.context.exclude_rule:
-            command += ['-excludeRule', jar_list_value(self.context.exclude_rule)]
+            if not split_rules and self.context.rule:
+                args += ['-rule',  jar_list_value(self.context.rule)]
+            elif split_rules and self.context.split_rules:
+                args += ['-rule', jar_list_value(self.context.split_rules)]
 
-        if not split_rules and self.context.rule:
-            command += ['-rule',  jar_list_value(self.context.rule)]
-        elif split_rules and self.context.split_rules:
-            command += ['-rule', jar_list_value(self.context.split_rules)]
-        try:
+            try:
+                Ctx.run_local_spec_check(False, self.context, args, print_errors=False)
+                lines = tmp_file.read().split("\n")
+                return set(lines)
 
-            result = subprocess.run(command, capture_output=True, text=True, check=True)
-            lines = result.stdout.strip().split("\n")
-            filtered_lines = [s for s in lines if not (s.startswith("Warning:") or " " in s)]
-            return set(filtered_lines)
-
-        except subprocess.CalledProcessError as e:
-            raise Util.CertoraUserInputError(f"Failed to get {'split ' if split_rules else ''}rules\ncommand: {command}\n{e}")
+            except Exception as e:
+                raise Util.CertoraUserInputError(f"Failed to get {'split ' if split_rules else ''}rules\n{e}")
 
     def run_commands(self) -> int:
         rule_flag = Attrs.EvmProverAttributes.RULE.get_flag()
         split_rules_flag = Attrs.EvmProverAttributes.SPLIT_RULES.get_flag()
         msg_flag = Attrs.CommonAttributes.MSG.get_flag()
+
+        # it is important to use the cache, when the difference between the runs is only the rules that apply
+        build_cache_flag = Attrs.EvmProverAttributes.BUILD_CACHE.get_flag()
+
         group_id_flag = Attrs.EvmProverAttributes.GROUP_ID.get_flag()
         disable_local_typechecking_flag = Attrs.EvmProverAttributes.DISABLE_LOCAL_TYPECHECKING.get_flag()
 
@@ -118,7 +123,7 @@ class SplitRulesHandler():
             if called as library then if running in local mode we use certoraRun.py otherwise certoraRun (from package)
             :return:
             """
-            assert Attrs.is_evm_app(), "Split rules is supported only for EVM apps"
+            assert self.context.app == App.EvmApp, "Split rules is supported only for EVM apps"
             if hasattr(self.context, 'prover_cmd'):
                 return self.context.prover_cmd
             if self.context.local:
@@ -137,7 +142,7 @@ class SplitRulesHandler():
                 self.context.msg = ''
 
             cmd = [get_cmd()] + args + [group_id_flag, self.context.group_id, disable_local_typechecking_flag,
-                                        split_rules_flag]
+                                        build_cache_flag, split_rules_flag]
 
             if self.split_rules:
                 for rule in self.split_rules:

certora_cli/CertoraProver/storageExtension.py

@@ -0,0 +1,351 @@
+#     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 re
+import time
+import hashlib
+import sys
+from pathlib import Path
+import logging
+from typing import Any, Dict, List, Optional, Set, Tuple
+try:
+    from typing import TypeAlias
+except ImportError:
+    from typing_extensions import TypeAlias
+
+scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
+sys.path.insert(0, str(scripts_dir_path))
+
+from CertoraProver.certoraBuildDataClasses import ContractInSDC
+from CertoraProver import erc7201
+from Shared import certoraUtils as Util
+from CertoraProver.certoraBuildDataClasses import SDC
+
+NameSpacedStorage: TypeAlias = Tuple[str, str]
+NewStorageFields = List[Dict[str, Any]]
+NewStorageTypes  = Dict[str, Any]
+NewStorageInfo   = Tuple[NewStorageFields, NewStorageTypes]
+
+storage_extension_logger = logging.getLogger("storage_extension")
+
+
+def erc7201_of_node(n: Dict[str, Any]) -> Optional[NameSpacedStorage]:
+    """
+    If n is a StructDefinition node, try and extract the @custom:storage-location
+    structured documentation, if it exists.
+
+    @returns (type, namespace) where 'type' is the name of the annotated type and
+                'namespace' is the namespace string
+    """
+    if n.get("nodeType") != "StructDefinition":
+        return None
+    typeName = n.get("canonicalName")
+    doc = n.get("documentation")
+    if doc is None or doc.get("nodeType") != "StructuredDocumentation" or typeName is None:
+        return None
+    storage_location_regex = r'@custom:storage-location erc7201:([a-zA-Z.0-9]+)'
+    match = re.search(storage_location_regex, doc.get("text"))
+    if match is None:
+        return None
+    ns = match.group(1)
+    return (typeName, ns)
+
+
+def generate_harness_name(original_file: str) -> str:
+    """
+    Generate a unique name for the harness contract based on the original file name.
+    The name is generated by hashing the original file name and appending a suffix to ensure uniqueness.
+    Args:
+        original_file (str): The path to the original file used to generate the harness name.
+    Returns:
+        str: A unique name for the harness contract.
+    """
+    stem = Path(original_file).stem
+    # 1) Compute an 8-hex salt from path+time
+    digest = hashlib.sha1(f"{original_file}{time.time()}".encode()).hexdigest()[:8]
+    suffix = f"_{digest}_Harness"
+    # 2) Reserve space for suffix so whole name ≤31 chars
+    max_stem = 31 - len(suffix)
+    if len(stem) > max_stem:
+        stem = stem[:max_stem]
+    # 3) Build, sanitize, and ensure start‐with‐letter
+    raw = f"{stem}{suffix}"
+    name = re.sub(r'[^A-Za-z0-9_]', '_', raw)
+    if not name[0].isalpha():
+        name = f"H{name[1:]}"
+    return name
+
+
+def get_next_file_index(self_file_to_sdc_name: Dict[Path, str], max_index: int = 1000) -> int:
+    """
+    Gets the next available file index for temporary files to avoid naming conflicts.
+
+    This method examines the existing SDC names in `file_to_sdc_name` dictionary and
+    extracts numeric indices from them. It identifies the highest index currently in use
+    and returns that value plus one. If no valid indices are found or if an error occurs,
+    a default value of 1000 is returned.
+
+    The method assumes SDC names follow the format "some_prefix_NUMBER", where NUMBER
+    is an integer that can be extracted from the last segment after splitting by underscore.
+    Args:
+        self_file_to_sdc_name (Dict[Path, str]): A dictionary mapping file paths to their SDC names.
+        max_index (int): The maximum index to return if no valid indices are found. Default is 1000.
+    Returns:
+        int: The next available file index, or a default value of 1000 if no valid indices are found.
+    """
+    try:
+        # If file_to_sdc_name is empty, return a default starting index
+        if not self_file_to_sdc_name:
+            return max_index
+
+        indices = []
+        for sdc_name in self_file_to_sdc_name.values():
+            parts = sdc_name.split("_")
+            if len(parts) > 1:  # Make sure there's at least one underscore
+                try:
+                    # Try to convert the last part to an integer
+                    index = int(parts[-1])
+                    indices.append(index)
+                except ValueError:
+                    # Skip if the last part isn't a number
+                    continue
+
+        # If we found no valid indices, return a default value
+        if not indices:
+            storage_extension_logger.debug(f"No valid indices found in file_to_sdc_name, using default value of {max_index}")
+            return max_index
+
+        return max(indices) + 1
+    except Exception:
+        # Fallback in case of any unexpected errors
+        storage_extension_logger.debug(f"Error determining next file index, using default value of {max_index}")
+        return max_index
+
+
+def write_harness_contract(tmp_file: Any,
+                           harness_name: str,
+                           ns_storage: Set[NameSpacedStorage]) -> Dict[str, str]:
+    """
+    Write the harness contract with dummy fields to the temporary file.
+
+    Args:
+        tmp_file: The temporary file to write to
+        harness_name: Name of the harness contract
+        ns_storage: Set of namespace storage declarations
+
+    Returns:
+        Dict[str, str]: Mapping from variable names to their slots
+    """
+    tmp_file.write(f"contract {harness_name} {{\n")
+
+    # Map from variable names to their slots
+    var_to_slot = {}
+
+    # Add dummy fields for each namespaced storage
+    for type_name, namespace in ns_storage:
+        # Create a variable name by replacing dots with underscores and appending the hash
+        # Add a prefix to ensure the variable name is valid in Solidity (e.g., no leading digits)
+        var_name = f"ext_{namespace.replace('.', '_')}"
+
+        # Calculate the slot using ERC-7201 formula
+        # UTF-8 is the standard encoding for Ethereum and Solidity
+        slot = str(erc7201.erc7201(namespace.encode('utf-8')))
+
+        var_to_slot[var_name] = slot
+        tmp_file.write(f"\t{type_name} {var_name};\n")
+
+    tmp_file.write("}\n")
+    return var_to_slot
+
+
+def extract_harness_contract_layout(sdcs: List[SDC], harness_name: str) -> Dict[str, Any]:
+    """
+    Extract the storage layout of the harness contract.
+
+    Args:
+        sdcs: List of SDCs containing the compiled contracts
+        harness_name: Name of the harness contract
+    Returns:
+        Dict[str, Any]: The storage layout of the harness contract
+    """
+
+    # Search through all SDC's to find the correct contract
+    harness_contract = None
+    for sdc in sdcs:
+        harness_contract = sdc.find_contract(harness_name)
+        if harness_contract:
+            break
+
+    if not harness_contract:
+        raise RuntimeError(f"Could not find harness contract {harness_name} in compiled output")
+    # Extract the storage layout
+    layout = harness_contract.storage_layout
+    if not layout or 'storage' not in layout:
+        raise RuntimeError(f"Invalid storage layout for harness contract {harness_name}")
+    return layout
+
+
+def remapped_fields_from_layout(layout: Dict[str, Any], var_to_slot: Dict[str, str]) -> NewStorageFields:
+    """
+    Remap the fields in the storage layout according to the variable to slot mapping.
+
+    Args:
+        layout: The storage layout of the harness contract
+        var_to_slot: Mapping from variable names to their slots
+
+    Returns:
+        List[Dict[str, Any]]: A list of remapped fields with updated slot information
+    """
+    remapped_fields = []
+    for storage_item in layout['storage']:
+        cloned_item = storage_item.copy()
+        var_name = cloned_item["label"]
+        if var_name in var_to_slot:
+            cloned_item["slot"] = var_to_slot[var_name]
+            remapped_fields.append(cloned_item)
+        else:
+            storage_extension_logger.warning(f"Skipping adding variable {var_name} not found in variable to slot mapping")
+
+    remapped_fields.sort(key=lambda f: int(f["slot"]))
+    return remapped_fields
+
+
+def get_namespace_storage_from_ast(def_node: Dict[str, Any]) -> Set[NameSpacedStorage]:
+    """
+    Extracts namespaced storage information from the AST nodes.
+
+    Args:
+        def_node: The AST node representing the contract definition.
+
+    Returns:
+        Set[NameSpacedStorage]: A set of namespaced storage information.
+    """
+    ns_storage: Set[NameSpacedStorage] = set()
+    nodes = def_node.get("nodes")
+    if not nodes:
+        # No nodes found in the contract definition
+        return ns_storage
+    for n in nodes:
+        sinfo = erc7201_of_node(n)
+        if sinfo is not None:
+            storage_extension_logger.debug(f"Found namespaced storage: {sinfo}")
+            ns_storage.add(sinfo)
+    return ns_storage
+
+
+def apply_extensions(target_contract: ContractInSDC,
+                     extensions: Set[str],
+                     to_add: Dict[str, NewStorageInfo]) -> None:
+    """
+    Apply the fields from each extension to the target contract,
+    @param target_contract contract to which to apply extensions
+    @param extensions set of extension contract names
+    @param to_add maps extension name in extensions to (storage layouts, new types)
+    """
+    storage_layout = target_contract.storage_layout
+    # Check if the target contract has a storage layout
+    if not storage_layout:
+        storage_extension_logger.warning(f"Target contract {target_contract.name} has no storage layout")
+        return
+
+    # Check if the target contract has a storage layout with 'storage' key
+    if "storage" not in storage_layout:
+        storage_extension_logger.warning(f"Target contract {target_contract.name} storage layout does not contain 'storage' key")
+        storage_layout["storage"] = []
+    elif not isinstance(storage_layout["storage"], list):
+        storage_extension_logger.warning(f"Target contract {target_contract.name} 'storage' is not a list but {type(storage_layout['storage']).__name__}: {storage_layout['storage']}")
+        storage_layout["storage"] = []
+
+    # Check if the target contract has a storage layout with 'types' key
+    if "types" not in storage_layout:
+        storage_extension_logger.warning(f"Target contract {target_contract.name} storage layout does not contain 'types' key")
+        storage_layout["types"] = {}
+    elif not isinstance(storage_layout["types"], dict):
+        storage_extension_logger.warning(f"Target contract {target_contract.name} 'types' is not a dict but {type(storage_layout['types']).__name__}: {storage_layout['types']}")
+        storage_layout["types"] = {}
+
+    target_slots = {storage["slot"] for storage in storage_layout["storage"]}
+    target_vars = {storage["label"] for storage in storage_layout["storage"]}
+    # Keep track of slots we've added, and error if we
+    # find two extensions extending the same slot
+    added_slots: Dict[str, str] = {}
+    added_vars: Dict[str, str] = {}
+    for ext in extensions:
+        # Check if the extension is in the to_add mapping
+        if ext not in to_add:
+            storage_extension_logger.warning(f"Extension {ext} not found in to_add mapping")
+            continue
+        (new_fields, new_types) = to_add[ext]
+        for field in new_fields:
+            # See if any of the new fields is a slot or variable name we've already added
+            slot = field["slot"]
+            var = field["label"]
+            validate_new_fields(
+                target_contract,
+                ext,
+                slot,
+                var,
+                added_slots,
+                added_vars,
+                target_slots,
+                target_vars
+            )
+
+            added_slots[slot] = ext
+            added_vars[var] = ext
+
+        # Add the fields to the storage layout
+        storage_layout["storage"].extend(new_fields)
+        storage_extension_logger.debug(f"Added {len(new_fields)} fields from extension {ext} to contract {target_contract.name}: {[field['label'] for field in new_fields]}")
+        for (new_id, new_ty) in new_types.items():
+            if new_id in storage_layout["types"]:
+                continue
+            storage_layout["types"][new_id] = new_ty
+
+
+def validate_new_fields(
+        target_contract: ContractInSDC,
+        ext: str,
+        slot: str,
+        var: str,
+        added_slots: Dict[str, str],
+        added_vars: Dict[str, str],
+        target_slots: Set[str],
+        target_vars: Set[str]) -> None:
+    """
+    Validate that the new fields being added to the target contract
+    do not conflict with existing fields or variables.
+
+    Args:
+        target_contract: The target contract to which the fields are being added
+        ext: The name of the extension contract
+        slot: The slot being added
+        var: The variable being added
+        added_slots: Dictionary of slots already added
+        added_vars: Dictionary of variables already added
+        target_slots: Set of slots in the target contract
+        target_vars: Set of variables in the target contract
+    """
+
+    if slot in added_slots:
+        seen = added_slots[slot]
+        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} was already added by {seen}")
+    if var in added_vars:
+        seen = added_vars[var]
+        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} was already added by {seen}")
+    if slot in target_slots:
+        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} is already mapped by {target_contract.name}")
+    if var in target_vars:
+        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} is already declared by {target_contract.name}")

certora_cli/EquivalenceCheck/Eq_default.conf

@@ -3,7 +3,6 @@
     "msg": "Equivalence Check",
     "optimistic_loop": true,
     "loop_iter": "4",
-    "process": "emv",
     "rule_sanity": "basic",
     "verify": "",
     "msg": ""

certora_cli/EquivalenceCheck/Eq_sanity.conf

@@ -4,6 +4,5 @@
     "msg": "Equivalence Check",
     "optimistic_loop": true,
     "loop_iter": "4",
-    "process": "emv",
     "verify": ""
 }

certora_cli/EquivalenceCheck/equivCheck.py

@@ -30,6 +30,7 @@ from CertoraProver.certoraBuild import InputConfig, CertoraBuildGenerator, Funct
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
 from CertoraProver.certoraContext import get_args
 from certoraRun import run_certora
+import CertoraProver.certoraApp as App
 
 LOG_PATH = Path('EqCheck_log.log')
 SANITY_PATH = Path('sanity.spec')
@@ -140,7 +141,7 @@ class EquivalenceChecker:
             tmp_conf = self.path / TMP_SANITY_CONF
             with tmp_conf.open('w') as temp_sanity:
                 json.dump(contents, temp_sanity, indent=4)
-            context = get_args([str(tmp_conf)])
+            context = get_args([str(tmp_conf)], App.EvmApp)
             config = InputConfig(context)
             cfb = CertoraBuildGenerator(config, context)
             certora_verify_generator = CertoraVerifyGenerator(context)

certora_cli/Mutate/mutateApp.py

@@ -28,7 +28,6 @@ from typing import Optional, Any, List, Dict, Tuple, Set, Union
 import logging
 from types import SimpleNamespace
 import tarfile
-import json5
 import csv
 import time
 import requests
@@ -44,7 +43,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
@@ -52,6 +53,7 @@ from Mutate import mutateAttributes as MutAttrs
 import CertoraProver.certoraContextAttributes as Attrs
 from CertoraProver.certoraContextClass import CertoraContext
 from rustMutator import run_universal_mutator
+from CertoraProver import certoraContextValidator as Cv
 
 class RunTimedout(Exception):
     pass
@@ -496,7 +498,7 @@ class WebUtils:
             mutation_test_domain = MConstants.MUTATION_TEST_REPORT_DEV
         else:
             raise Util.CertoraUserInputError(f"Invalid server name {args.server}")
-        self.mutation_test_id_url = f"https://{domain}/mutationTesting/initiate/"
+        self.mutation_test_id_url = f"https://{domain}/v1/domain/mutation-tests/initiate/"
         self.mutation_test_submit_final_result_url = f"https://{domain}/mutationTesting/getUploadInfo/"
         self.mutation_test_final_result_url = f"https://{mutation_test_domain}"
         mutation_logger.debug(f"Using server {args.server} with mutation_test_id_url {self.mutation_test_id_url}")
@@ -542,8 +544,8 @@ class WebUtils:
             try:
                 return requests.put(url, json=body, timeout=self.request_timeout,
                                     headers=headers)
-            except Exception:
-                mutation_logger.debug(f"attempt {i} failed to put url {url}.")
+            except Exception as e:
+                mutation_logger.debug(f"attempt {i} failed to put url {url}. {e}")
         return None
 
     def get_response_with_timeout(self, url: str,
@@ -708,6 +710,7 @@ class MutateApp:
     dump_csv: Optional[Path]
     sync: bool
     wait_for_original_run: bool
+    url_visibility: Vf.UrlVisibilityOptions
     collect_file: Optional[Path]
     poll_timeout: Optional[int]
     max_timeout_attempts_count: Optional[int]
@@ -720,7 +723,7 @@ class MutateApp:
     def __init__(self, args_list: List[str]) -> None:
         self.mutation_test_id = ''
         self.numb_of_jobs: int = 0
-        self.backup_paths: List[Path] = []
+        self.backup_path: Optional[Path] = None
         self.sources_dir: Optional[Path] = None
         self.with_split_stats_data = False
         self.manual_mutants_list: List[Mutant] = list()
@@ -879,9 +882,9 @@ class MutateApp:
                                                      " verification results. Please remove or replace the mutation")
 
     def restore_backups(self) -> None:
-        for backup_path in self.backup_paths:
-            Util.restore_backup(backup_path)
-        self.backup_paths = []
+        if self.backup_path:
+            Util.restore_backup(self.backup_path)
+        self.backup_path = None
 
     def submit_soroban(self) -> None:
 
@@ -928,12 +931,14 @@ class MutateApp:
         # run mutants
         mutant_runs = []
         try:
-            self.backup_paths = []
             for mutant in all_mutants:
                 # call certoraRun for each mutant we found
                 mutant_runs.append(self.run_mutant_soroban(mutant))
+                self.restore_backups()
         finally:
-            self.restore_backups()
+            if self.backup_path:
+                mutation_logger.warning("Not empty backup path")
+                self.restore_backups()
 
         # wrap it all up and make the input for the 2nd step: the collector
         assert self.collect_file, "submit_soroban: no collect_file"
@@ -1141,10 +1146,11 @@ class MutateApp:
     def run_mutant_soroban(self, mutant: Mutant) -> MutantJob:
         file_to_mutate = Path(mutant.original_filename)
         # create a backup copy (if needed) by adding '.backup' to the end of the file
-        if Util.get_backup_path(file_to_mutate) not in self.backup_paths:
-            backup_file = Util.create_backup(file_to_mutate)
-            assert backup_file, f"run_mutant_soroban: create_backup for {file_to_mutate} failed"
-            self.backup_paths.append(backup_file)
+        if self.backup_path and Util.get_backup_path(file_to_mutate) != self.backup_path:
+            raise Util.ImplementationError("backup_path is set but does not match the file to mutate")
+        if not self.backup_path:
+            self.backup_path = Util.create_backup(file_to_mutate)
+            assert self.backup_path, f"run_mutant_soroban: create_backup for {file_to_mutate} failed"
         shutil.copy(mutant.filename, file_to_mutate)
 
         try:
@@ -1180,6 +1186,7 @@ class MutateApp:
         if solc:
             compiler = solc
         elif compiler_map:
+            Cv.check_contract_name_arg_inputs(self.prover_context)
             compiler = get_relevant_compiler(path_to_file, self.prover_context)
             if not compiler:
                 raise Util.CertoraUserInputError(f"Cannot resolve Solidity compiler for {path_to_file}: "
@@ -1255,6 +1262,8 @@ class MutateApp:
         for gambit_obj in self.gambit:
             if MConstants.NUM_MUTANTS not in gambit_obj:
                 gambit_obj[MConstants.NUM_MUTANTS] = DEFAULT_NUM_MUTANTS
+            else:
+                gambit_obj[MConstants.NUM_MUTANTS] = int(gambit_obj[MConstants.NUM_MUTANTS])
             gambit_obj[MConstants.SOLC] = self.get_solc_version(Path(gambit_obj[MConstants.FILENAME]))
             gambit_obj.update(shared_attributes)
         with MConstants.TMP_GAMBIT_PATH.open('w') as f:
@@ -1373,7 +1382,7 @@ class MutateApp:
         for mutant in self.universal_mutator:
             file_to_mutate = Path(os.path.normpath(mutant[MConstants.FILE_TO_MUTATE]))
             mutants_location = Path(mutant[MConstants.MUTANTS_LOCATION])
-            num_of_mutants = mutant[MConstants.NUM_MUTANTS]
+            num_of_mutants = int(mutant[MConstants.NUM_MUTANTS])
             run_universal_mutator(file_to_mutate, self.prover_context.build_script, mutants_location, num_of_mutants)
             self.add_dir_to_mutants(ret_mutants, mutants_location, file_to_mutate)
         return ret_mutants
@@ -1385,6 +1394,8 @@ class MutateApp:
             args = ["--compilation_steps_only"]
             if self.prover_version:
                 args += ['--prover_version', self.prover_version]
+            if self.server:
+                args += ['--server', self.server]
             run_certora([str(self.conf)] + args)
         except CertoraFoundViolations:  # violations should not stop execution
             pass
@@ -1401,6 +1412,8 @@ class MutateApp:
         certora_args = [str(conf_file), "--run_source", "MUTATION", "--msg", msg]
         if self.wait_for_original_run:
             certora_args.append("--wait_for_results")
+        if self.url_visibility:
+            certora_args.extend(["--url_visibility", str(self.url_visibility)])
         if self.with_split_stats_data and os.environ.get("WITH_AUTOCONFING", False) == '1':
             certora_args += ['--prover_resource_files', f"ac:{MConstants.SPLIT_STATS_DATA}"]
         if mutation_test_id:
@@ -1416,7 +1429,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
@@ -1865,7 +1881,7 @@ class MutateApp:
 
         with open(self.conf, 'r') as conf_file:
             try:
-                self.prover_context = CertoraContext(**json5.load(conf_file, allow_duplicate_keys=False))
+                self.prover_context = CertoraContext(**Util.read_conf_file(conf_file))
                 self.check_prover_context()
             except Exception as e:
                 raise Util.CertoraUserInputError(f"Failed to parse {self.conf} as JSON", e)
@@ -1893,7 +1909,7 @@ class MutateApp:
             common_flags.extend(['--optimize'])
 
         if hasattr(self.prover_context, MConstants.SOLC_ALLOW_PATH):
-            common_flags.extend([f'--allow-paths, {self.prover_context.solc_allow_path}'])
+            common_flags.extend(['--allow-paths', '/'])
 
         if hasattr(self.prover_context, MConstants.SOLC_EVM_VERSION):
             common_flags.extend(['--evm-version', self.prover_context.solc_evm_version])
@@ -1908,7 +1924,9 @@ class MutateApp:
         if not self.manual_mutants:
             return
 
-        solc = self.get_solc_version(trg_dir)
+        solc = self.get_solc_version(Path(mutant.original_filename))
+        if not solc:
+            raise Util.CertoraUserInputError(f"Unable to find a compiler for manual mutant {mutant.original_filename}")
 
         via_ir_flag = []
         if getattr(self.prover_context, MConstants.SOLC_VIA_IR, '') or \
@@ -1919,10 +1937,11 @@ class MutateApp:
         if self.test == str(Util.TestValue.CHECK_MANUAL_COMPILATION):
             raise Util.TestResultsReady(' '.join(args))
         with Util.change_working_directory(find_cwd(trg_dir)):
-            result = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            result = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
         if result.returncode:
             mutation_logger.debug(f"mutation compilation failed: cmd: {' '.join(args)}\n cwd: {os.getcwd()}")
-            raise Util.CertoraUserInputError(f"mutation file {mutant.filename} failed to compile")
+            raise Util.CertoraUserInputError(f"mutation file {mutant.filename} failed to compile\n\n"
+                                             f"{result.stderr.decode()}")
 
 
 def rec_collect_statuses_children(rule: Dict[str, Any], statuses: List[str]) -> None: