certora-cli 7.20.3__tar.gz → 7.21.1__tar.gz

{certora_cli-7.20.3/certora_cli.egg-info → certora_cli-7.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certora-cli
-Version: 7.20.3
+Version: 7.21.1
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -21,5 +21,6 @@ Requires-Dist: tabulate
 Requires-Dist: tqdm
 Requires-Dist: StrEnum
 Requires-Dist: tomli
+Requires-Dist: universalmutator
 
-Commit 7b9a1c7.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 03eae31.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli-7.21.1/README.md

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

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraBuild.py

@@ -515,11 +515,11 @@ class CertoraBuildGenerator:
             ret = Path(self.function_finder_file_remappings[file])
         else:
             ret = Path(file)
-        abs_sources_dir = Util.get_certora_sources_dir().resolve()
+        abs_sources_dir = Util.get_certora_sources_dir().absolute()
         if abs_sources_dir in ret.parents:
             # Normalize the file-name to never include the extra `.certora_internal/.../.certora_sources` part
             # of the path.
-            ret = ret.relative_to(abs_sources_dir).resolve()
+            ret = Util.abs_norm_path(ret.relative_to(abs_sources_dir))
 
         # things look nicer if they are rooted in .certora_sources
         # note that we only have those fully populated after starting to work on internal function finders
@@ -1104,12 +1104,12 @@ class CertoraBuildGenerator:
           function name, inputs, outputs, stateMutability) for each contract
         """
         func_signatures = []
-        file_abs_path = Path(self.to_autofinder_file(str(contract_file))).resolve()
+        file_abs_path = Path(self.to_autofinder_file(str(contract_file))).absolute()
         if file_abs_path.suffix == VY:
             smart_contract_lang: CompilerLang = CompilerLangVy()
-            sdc_name = self.file_to_sdc_name[Path(contract_file).resolve()]
+            sdc_name = self.file_to_sdc_name[Path(contract_file).absolute()]
             standard_json_data = self.get_standard_json_data(sdc_name, smart_contract_lang)
-            abi = standard_json_data[CONTRACTS][str(Path(contract_file).resolve())][contract_name]['abi']
+            abi = standard_json_data[CONTRACTS][str(Path(contract_file).absolute())][contract_name]['abi']
             ast_logger.debug(f"abi is: \n{abi}")
             for f in filter(lambda x: self.is_imported_abi_entry(x), abi):
                 func_signature = self.get_full_func_signature(f)
@@ -1347,6 +1347,11 @@ class CertoraBuildGenerator:
             settings_dict["optimizer"] = {"enabled": True}
             if int(self.context.solc_optimize) > 0:
                 settings_dict["optimizer"]['runs'] = int(self.context.solc_optimize)
+
+        # if optimizer is true, we should also define settings_dict["optimizer"]["details"]
+        # for both optimize map and optimize
+        optimizer = settings_dict.get("optimizer")
+        if optimizer and isinstance(optimizer, dict) and optimizer.get('enabled'):
             # if we are not disabling finder friendly optimizer specifically, enable it whenever viaIR is also enabled
             if not self.context.strict_solc_optimizer and (
                     self.context.solc_via_ir or self.context.solc_experimental_via_ir):
@@ -1692,7 +1697,7 @@ class CertoraBuildGenerator:
         is_vyper = smart_contract_lang == CompilerLangVy()
         sdc_name = f"{Path(build_arg_contract_file).name}_{file_index}"
         compilation_path = self.get_compilation_path(sdc_name)
-        self.file_to_sdc_name[Path(build_arg_contract_file).resolve()] = sdc_name
+        self.file_to_sdc_name[Util.abs_norm_path(build_arg_contract_file)] = sdc_name
         # update remappings and collect_cmd:
         if not is_vyper:
             Util.safe_create_dir(compilation_path)
@@ -1714,7 +1719,7 @@ class CertoraBuildGenerator:
                 is equivalent to `main_path = self.context.solc_allow_path`, and that's the best we can do in that
                 case anyway.
                 """
-                main_path = (compile_wd / self.context.solc_allow_path).resolve()
+                main_path = (compile_wd / self.context.solc_allow_path).absolute()
             else:
                 main_path = self.context.solc_allow_path
             self.context.solc_cmd_allow_paths = [f'"{main_path}"', '.']
@@ -1813,7 +1818,8 @@ class CertoraBuildGenerator:
             contract_file = str(contract_file_obj)
             build_logger.debug(f"Processing dependencies from file {contract_file}")
             # make sure path name is in posix format.
-            contract_file_abs = Path(contract_file).resolve().as_posix()
+            contract_file_abs = str(Util.abs_norm_path(contract_file))
+
             # using os.path.relpath because Path.relative_to cannot go up the directory tree (no ..)
             contract_file_rel = os.path.relpath(Path(contract_file_abs), Path.cwd())
 
@@ -1849,7 +1855,7 @@ class CertoraBuildGenerator:
                     base_contracts = sorted(self.retrieve_base_contracts_list(build_arg_contract_file, contract_file,
                                                                               contract_name), key=lambda x: x[0])
                     for c_file, _, _ in base_contracts:
-                        norm_c_file = Path(c_file).resolve()
+                        norm_c_file = Util.abs_norm_path(c_file)
                         resolved_to_orig[str(norm_c_file)] = c_file
                         if norm_c_file not in seen_link_refs:
                             build_logger.debug(f"Adding a base contract link ref {norm_c_file} to worklist")
@@ -1860,7 +1866,7 @@ class CertoraBuildGenerator:
                     contract_object = data[CONTRACTS][contract_file][contract_name]
                     lib_link_refs = sorted(contract_object["evm"]["deployedBytecode"]["linkReferences"])
                     for lib_link_ref in lib_link_refs:  # linkReference is a library reference
-                        norm_link_ref = Path(lib_link_ref).resolve()
+                        norm_link_ref = Path(lib_link_ref).absolute()
                         resolved_to_orig[str(norm_link_ref)] = lib_link_ref
                         if norm_link_ref not in seen_link_refs:
                             build_logger.debug(f"Adding library link ref {norm_link_ref} to worklist")
@@ -1879,8 +1885,7 @@ class CertoraBuildGenerator:
                         contract_refs = [c_file for c_file in
                                          data[CONTRACTS].keys() if
                                          ref in data[CONTRACTS][c_file].keys()]
-                        contract_files_resolved = sorted([Path(x).resolve() for x in
-                                                          contract_refs])
+                        contract_files_resolved = sorted([Util.abs_norm_path(x) for x in contract_refs])
 
                         # There may be two non unique paths but actually referring to the same absolute path.
                         # Normalizing as absolute
@@ -2302,7 +2307,7 @@ class CertoraBuildGenerator:
                                                  f" {c.name} that doesn't have a location")
                     return None
 
-                instrumentation_path = Util.convert_path_for_solc_import(loc[0])
+                instrumentation_path = str(Util.abs_norm_path(loc[0]))
                 if instrumentation_path not in function_finder_instrumentation:
                     instrumentation_logger.debug(f"New instrumentation for location {loc[0]}, " +
                                                  f"instrumentation path {instrumentation_path}")
@@ -2879,7 +2884,7 @@ class CertoraBuildGenerator:
         p = Path(path)
         if p.is_absolute():
             return path
-        return str(Path.cwd() / p.resolve())
+        return str(Path.cwd() / p.absolute())
 
     @staticmethod
     def merge_dicts_instrumentation(dict1: Dict[str, Dict[int, Instrumentation]],
@@ -3052,7 +3057,7 @@ class CertoraBuildGenerator:
         """
         rel_to_cwd_path = Path(os.path.relpath(path, '.'))
         new_path = Util.get_certora_sources_dir() / self.cwd_rel_in_sources / rel_to_cwd_path
-        return str(new_path.resolve())
+        return str(new_path.absolute())
 
     def handle_links(self) -> None:
         # Link processing
@@ -3481,7 +3486,7 @@ def build_from_scratch(certora_build_generator: CertoraBuildGenerator,
     saw_paths_not_in_sources = False
     paths_not_in_sources = set()
     may_store_in_build_cache = True
-    absolute_sources_dir = Util.get_certora_sources_dir().resolve()
+    absolute_sources_dir = Util.get_certora_sources_dir().absolute()
     for sdc in certora_build_generator.SDCs.values():
         # the contract files in SDCs are relative to .certora_sources. Which isn't good for us here.
         # Need to be relative to original paths

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraCloudIO.py

@@ -847,7 +847,7 @@ class CloudVerification:
         self.vscode_extension_info_writer.add_field("verification_report_url", self.reportUrl)
         self.vscode_extension_info_writer.write_file()
 
-        if wait_for_results == str(Vf.WaitForResultOptions.NONE):
+        if not wait_for_results or wait_for_results == str(Vf.WaitForResultOptions.NONE):
             job_list.save_data()
             job_list.save_recent_jobs_to_path()
             self.print_output_links()

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraCollectRunMetadata.py

@@ -149,7 +149,7 @@ def collect_run_metadata(wd: Path, raw_args: List[str], context: CertoraContext)
                            group_id=None)
 
     # collect information about current git snapshot
-    cwd_abs = wd.resolve()
+    cwd_abs = wd.absolute()
 
     is_git_executable = False
     git_present_out = None

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraContext.py

@@ -528,7 +528,7 @@ def run_local_spec_check(with_typechecking: bool, context: CertoraContext) -> No
                                          "To skip local checks run with the --disable_local_typechecking flag")
 
 def set_cargo_name(context: CertoraContext) -> None:
-    mode = "rb" if platform.system() == 'Darwin' else "r"
+    mode = "r" if platform.system().lower() == 'windows' else "rb"
     with open(context.cargo_file, mode) as f:
         cargo_data = tomllib.load(f)
 
@@ -550,7 +550,7 @@ def build_wasm(context: CertoraContext) -> None:
 
 def run_wasm_compiler(context: CertoraContext) -> None:
     env = os.environ.copy()
-    env['RUSTFLAGS'] = "-C strip=none -C debuginfo=2"
+    env['RUSTFLAGS'] = "-C strip=none --emit=llvm-ir -C debuginfo=2"
     try:
         context_logger.info("Executing build process...")
 

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraContextAttributes.py

@@ -130,6 +130,24 @@ class CommonAttributes(AttrUtil.Attributes):
         affects_build_cache_key=False,
         disables_build_cache=False
     )
+    # used by certoraMutate, ignored by certoraRun
+    MUTATIONS = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.MAP,
+        argparse_args={
+            'action': AttrUtil.NotAllowed
+        },
+        affects_build_cache_key=False,
+        disables_build_cache=False
+    )
+
+    RUN_SOURCE = AttrUtil.AttributeDefinition(
+        attr_validation_func=Vf.validate_run_source,
+        argparse_args={
+            'action': AttrUtil.UniqueStore
+        },
+        affects_build_cache_key=False,
+        disables_build_cache=False
+    )
 
 class DeprecatedAttributes(AttrUtil.Attributes):
     AUTO_NONDET_DIFFICULT_INTERNAL_FUNCS = AttrUtil.AttributeDefinition(
@@ -707,15 +725,7 @@ class EvmAttributes(AttrUtil.Attributes):
         affects_build_cache_key=True,
         disables_build_cache=True
     )
-    # used by certoraMutate, ignored by certoraRun
-    MUTATIONS = AttrUtil.AttributeDefinition(
-        arg_type=AttrUtil.AttrArgType.MAP,
-        argparse_args={
-            'action': AttrUtil.NotAllowed
-        },
-        affects_build_cache_key=False,
-        disables_build_cache=False
-    )
+
     DISABLE_INTERNAL_FUNCTION_INSTRUMENTATION = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
         argparse_args={
@@ -852,15 +862,6 @@ class BackendAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
-    RUN_SOURCE = AttrUtil.AttributeDefinition(
-        attr_validation_func=Vf.validate_run_source,
-        argparse_args={
-            'action': AttrUtil.UniqueStore
-        },
-        affects_build_cache_key=False,
-        disables_build_cache=False
-    )
-
     LOOP_ITER = AttrUtil.AttributeDefinition(
         attr_validation_func=Vf.validate_non_negative_integer,
         jar_flag='-b',

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/EVMVerifier/certoraContextValidator.py

@@ -133,7 +133,7 @@ class CertoraContextValidator:
                 # the absolute one.
                 pass
 
-        set_relative_paths(context)
+        set_bytecode_relative_paths(context)
         check_files_input(context.files)
         check_vyper_flag(context)
         check_compiler_map_flag(context)
@@ -762,7 +762,7 @@ def to_relative_paths(paths: Union[str, List[str]]) -> Union[str, List[str]]:
     if isinstance(paths, list):
         return [os.path.relpath(path, cwd) for path in paths]
 
-def set_relative_paths(context: CertoraContext) -> None:
+def set_bytecode_relative_paths(context: CertoraContext) -> None:
     for attr in [Attrs.EvmProverAttributes.BYTECODE_JSONS.get_conf_key(),
                  Attrs.EvmProverAttributes.BYTECODE_SPEC.get_conf_key()]:
         value = getattr(context, attr, None)

{certora_cli-7.20.3 → certora_cli-7.21.1}/certora_cli/Mutate/mutateApp.py

@@ -36,6 +36,7 @@ from Mutate import mutateUtil as MutUtil
 from Mutate import mutateAttributes as MutAttrs
 import EVMVerifier.certoraContextAttributes as Attrs
 from EVMVerifier.certoraContextClass import CertoraContext
+from rustMutator import run_universal_mutator
 
 class RunTimedout(Exception):
     pass
@@ -43,7 +44,6 @@ class RunTimedout(Exception):
 
 DEFAULT_NUM_MUTANTS = 5
 ENV_FREE_CHECK = 'envfreeFuncsStaticCheck'
-PATCH_SUFFIXES = ['.sol', '.patch']
 
 mutation_logger = logging.getLogger("mutation")
 
@@ -600,7 +600,7 @@ def convert_to_mutation_testing_status(treeview_status: str) -> str:
         return MutationTestRuleStatus.UNKNOWN.value
 
 
-def generate_manual_mutant_object(manual_mutant: Path, orig_file: Path) -> Mutant:
+def mutant_object_from_path(manual_mutant: Path, orig_file: Path) -> Mutant:
     """
     Generate a Mutant object for a manual mutation.
 
@@ -699,9 +699,13 @@ class MutateApp:
     request_timeout: Optional[int]
     gambit: Union[Dict, List, None]
     manual_mutants: Optional[Dict]
+    universal_mutator: Optional[Dict]
     prover_context: CertoraContext
 
-    def __init__(self, args_list: List[str] = []) -> None:
+    def __init__(self, args_list: List[str]) -> None:
+        self.mutation_test_id = ''
+        self.numb_of_jobs: int = 0
+        self.backup_paths: List[Path] = []
         self.sources_dir: Optional[Path] = None
         self.with_split_stats_data = False
         self.manual_mutants_list: List[Mutant] = list()
@@ -710,6 +714,13 @@ class MutateApp:
         self.read_conf_file()
         self.server = self.config_server()
 
+    def is_soroban_run(self) -> bool:
+        try:
+            files = self.prover_context.files
+        except AttributeError:
+            return False
+        return Util.CARGO_FILE in files or any(Path(path).suffix == '.wasm' for path in files)
+
     def config_server(self) -> str:
         """
         If given a server, it is taken.
@@ -856,7 +867,58 @@ class MutateApp:
                     raise Util.CertoraUserInputError(f"The mutated file, {file_to_mutate}, does not affect"
                                                      " verification results. Please remove or replace the mutation")
 
-    def submit(self) -> None:
+    def restore_backups(self) -> None:
+        for backup_path in self.backup_paths:
+            Util.restore_backup(backup_path)
+        self.backup_paths = []
+
+    def submit_soroban(self) -> None:
+        mutation_logger.info("Generating mutants and submitting...")
+        generated_mutants: List[Mutant] = self.get_universal_mutator_mutants()
+
+        web_utils = WebUtils(SimpleNamespace(**vars(self)))
+        # get the mutation test id
+        self.numb_of_jobs = len(generated_mutants)
+        self.mutation_test_id, collect_presigned_url = self.get_mutation_test_id_request(web_utils,
+                                                                                         self.numb_of_jobs + 1)
+        mutation_logger.debug(f"Mutation test id: {self.mutation_test_id}")
+        print_separator('PROVER START')
+        # run original run. if it fails to compile, nothing to continue with
+
+        try:
+            original_run_result = self.run_certora_prover(self.conf, self.mutation_test_id, msg=MConstants.ORIGINAL)
+        except Exception as e:
+            raise Util.CertoraUserInputError(f"Orig run: {e}")
+        if not original_run_result:
+            raise Util.CertoraUserInputError("No Orig results")
+        result_link = original_run_result.rule_report_link
+        assert result_link, "submit_soroban: Null result_link"
+
+        if not Vf.Util.is_valid_url(urllib3.util.parse_url(result_link)):
+            raise Util.CertoraUserInputError(f"Invalid certoraRun result: {result_link}")
+        print_separator('PROVER END')
+        # run mutants
+        mutant_runs = []
+        try:
+            self.backup_paths = []
+            for mutant in generated_mutants:
+                # call certoraRun for each mutant we found
+                mutant_runs.append(self.run_mutant_soroban(mutant))
+        finally:
+            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"
+        with self.collect_file.open('w+') as collect_file:
+            collect_data = {MConstants.ORIGINAL: result_link,
+                            MConstants.MUTANTS: [dataclasses.asdict(m) for m in mutant_runs]}
+            json.dump(collect_data, collect_file, indent=4)
+
+        self.upload_file_to_cloud_storage(web_utils, collect_presigned_url, collect_data)
+        self.print_notification_msg()
+        mutation_logger.info(f"... completed submit phase! Now we poll on {self.collect_file}...")
+
+    def submit_evm(self) -> None:
         mutation_logger.info("Generating mutants and submitting...")
 
         # ensure .certora_internal exists
@@ -875,7 +937,7 @@ class MutateApp:
             sys.exit(0)  # we exit here so we will not continue with collect in case of sync mode
 
         if self.manual_mutants:
-            self.manual_mutants_list = self.parse_manual_mutations()
+            self.manual_mutants_list = self.get_manual_mutations_mutants()
             mutation_logger.debug(f"successfully parsed manual mutants from {self.conf}")
 
         # match a generated mutant to a directory where we will apply the diff
@@ -910,7 +972,7 @@ class MutateApp:
             if certora_run_result:
                 self.sources_dir = certora_run_result.src_dir
 
-                assert certora_run_result.rule_report_link, "submit: no certora_run_result.rule_report_link"
+                assert certora_run_result.rule_report_link, "submit_evm: no certora_run_result.rule_report_link"
                 result_link = certora_run_result.rule_report_link
                 if self.wait_for_original_run:
                     if wait_for_job(result_link) and download_report_file(result_link, MConstants.SPLIT_STATS_DATA):
@@ -938,7 +1000,7 @@ class MutateApp:
             with prover_conf.open('w') as p_conf:
                 json.dump(prover_conf_content.__dict__, p_conf)
             shutil.copy(prover_conf, self.sources_dir)
-            assert self.orig_run_dir, "submit: orig_run_dir"
+            assert self.orig_run_dir, "submit_evm: orig_run_dir"
             src = self.orig_run_dir / MConstants.TARNAME / MConstants.REPORTS / MConstants.SPLIT_STATS_DATA
             if src.is_file():
                 try:
@@ -968,14 +1030,14 @@ class MutateApp:
         num_processes_for_mp = None
         max_task_per_worker = None
 
-        # For debug call run_mutant in same process
+        # For debug call run_mutant_evm in same process
         # runs = [(mutant, trg_dir, prover_conf,
         #          mutation_test_id, numb_of_jobs) for mutant, trg_dir in all_mutants_with_target_dir]
         # mutant_runs = []
         # for run in runs:
-        #     mutant_runs.append(self.run_mutant(*run))
+        #     mutant_runs.append(self.run_mutant_evm(*run))
         with multiprocessing.Pool(processes=num_processes_for_mp, maxtasksperchild=max_task_per_worker) as pool:
-            mutant_runs = pool.starmap(self.run_mutant,
+            mutant_runs = pool.starmap(self.run_mutant_evm,
                                        [(mutant, trg_dir, prover_conf, mutation_test_id, numb_of_jobs)
                                         for mutant, trg_dir in all_mutants_with_target_dir])
 
@@ -986,7 +1048,7 @@ class MutateApp:
         mutation_logger.debug([dataclasses.asdict(m) for m in mutant_runs])
 
         # wrap it all up and make the input for the 2nd step: the collector
-        assert self.collect_file, "submit: no collect_file"
+        assert self.collect_file, "submit_evm: no collect_file"
         with self.collect_file.open('w+') as collect_file:
             collect_data = {MConstants.ORIGINAL: result_link,
                             MConstants.MUTANTS: [dataclasses.asdict(m) for m in mutant_runs]}
@@ -1015,8 +1077,8 @@ class MutateApp:
         if self.with_split_stats_data and os.environ.get("WITH_AUTOCONFING", False) == '1':
             shutil.copy(Path.cwd() / MConstants.SPLIT_STATS_DATA, find_cwd(trg_dir))
 
-    def run_mutant(self, mutant: Mutant, trg_dir: Path, orig_conf: Path,
-                   mutation_test_id: str, numb_of_jobs: int) -> MutantJob:
+    def run_mutant_evm(self, mutant: Mutant, trg_dir: Path, orig_conf: Path,
+                       mutation_test_id: str, numb_of_jobs: int) -> MutantJob:
 
         MutUtil.TOTAL_MUTANTS = numb_of_jobs
         with Util.change_working_directory(find_cwd(trg_dir)):
@@ -1033,7 +1095,7 @@ class MutateApp:
                     rule_report_link=None
                 )
 
-            assert certora_run_result, f"run_mutant: no result {mutant.id} "
+            assert certora_run_result, f"run_mutant_evm: no result {mutant.id} "
 
             link = certora_run_result.link
             self.sources_dir = certora_run_result.src_dir
@@ -1046,6 +1108,38 @@ class MutateApp:
                 rule_report_link=certora_run_result.rule_report_link
             )
 
+    def run_mutant_soroban(self, mutant: Mutant) -> MutantJob:
+        file_to_mutate = Path(mutant.original_filename)
+        if file_to_mutate not in self.backup_paths:
+            # create a backup copy by adding '.backup' to the end of the file
+            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)
+        shutil.copy(mutant.filename, file_to_mutate)
+
+        try:
+            certora_run_result = self.run_certora_prover(self.conf, self.mutation_test_id, msg=f"mutant ID: {mutant.id}")
+        except Util.CertoraUserInputError:
+            return MutantJob(
+                gambit_mutant=mutant,
+                success=False,
+                run_directory="",
+                link=None,
+                rule_report_link=None
+            )
+
+        assert certora_run_result, f"run_mutant_soroban: no result {mutant.id} "
+
+        link = certora_run_result.link
+
+        return MutantJob(
+            gambit_mutant=mutant,
+            success=True,
+            run_directory="",
+            link=link,
+            rule_report_link=certora_run_result.rule_report_link
+        )
+
     def get_solc_version(self, path_to_file: Path) -> str:
         solc = getattr(self.prover_context, 'solc', '')
         solc_map = getattr(self.prover_context, 'solc_map', None)
@@ -1125,7 +1219,7 @@ class MutateApp:
         evm_version = getattr(self.prover_context, 'solc_evm_version', None)
         if evm_version:
             shared_attributes['solc_evm_version'] = evm_version
-        assert self.gambit, "submit: no gambit"
+        assert self.gambit, "submit_evm: no gambit"
         for gambit_obj in self.gambit:
             if MConstants.NUM_MUTANTS not in gambit_obj:
                 gambit_obj[MConstants.NUM_MUTANTS] = DEFAULT_NUM_MUTANTS
@@ -1179,52 +1273,78 @@ class MutateApp:
         mutation_logger.debug("Got mutant information")
         return ret_mutants
 
-    @staticmethod
-    def add_file_to_mutants(manual_mutants: List[Mutant], mutation_file: Path, file_to_mutate: Path) -> None:
-        if mutation_file.suffix in PATCH_SUFFIXES:
-            manual_mutant_obj = generate_manual_mutant_object(mutation_file, file_to_mutate)
-            manual_mutants.append(manual_mutant_obj)
+    def valid_extensions(self) -> List[str]:
+        if self.is_soroban_run():
+            return ['.rs']
+        else:
+            return ['.sol', '.patch']
+
+    def add_file_to_mutants(self, mutants: List[Mutant], mutation_file: Path, file_to_mutate: Path) -> None:
+
+        if mutation_file.suffix in self.valid_extensions():
+            mutant_obj = mutant_object_from_path(mutation_file, file_to_mutate)
+            mutants.append(mutant_obj)
         else:
             raise Util.CertoraUserInputError(f"Illegal mutant file, {mutation_file.name},"
-                                             " extension must be .sol or .patch")
+                                             f" extension must be {' or '.join(self.valid_extensions())}")
 
-    @staticmethod
-    def add_dir_to_mutants(manual_mutants: List[Mutant], mutation_dir: Path, file_to_mutate: Path) -> None:
-        mutation_dir_path = Path(mutation_dir).resolve()
-        manual_mutants_files = [p for p in mutation_dir_path.glob('*') if p.is_file() and p.suffix in PATCH_SUFFIXES]
+    def add_dir_to_mutants(self, manual_mutants: List[Mutant], mutation_dir: Path, file_to_mutate: Path) -> None:
+        mutation_dir_path = Path(mutation_dir)
+        manual_mutants_files = \
+            [p for p in mutation_dir_path.glob('*') if p.is_file() and p.suffix in self.valid_extensions()]
         if not manual_mutants_files:
             raise Util.CertoraUserInputError(
                 f"Could not find any manual mutation files at {mutation_dir}")
         for file in manual_mutants_files:
-            MutateApp.add_file_to_mutants(manual_mutants, file, file_to_mutate)
+            self.add_file_to_mutants(manual_mutants, file, file_to_mutate)
 
-    def parse_manual_mutations(self) -> List[Mutant]:
+    def get_manual_mutations_mutants(self) -> List[Mutant]:
         """
-        Parse manual mutations from a configuration file.
+        Get manual mutations from manual_mutations attribute
 
         Returns:
-        - A list of Mutant objects representing the parsed manual mutations.
+        - A list of Mutant objects representing the found manual mutations.
 
         Raises:
-        - `FileNotFoundError`: If the mutation configuration file does not exist.
+        - `CertoraUserInputError`: If the mutation configuration file does not exist.
         """
 
         ret_mutants: List[Mutant] = []
-        assert self.manual_mutants, "parse_manual_mutations: self.manual_mutants"
+        assert self.manual_mutants, "get_manual_mutations_mutants: self.manual_mutants"
         for mutant in self.manual_mutants:
             file_to_mutate = Path(os.path.normpath(mutant[MConstants.FILE_TO_MUTATE]))
             path_to_orig = Path(file_to_mutate).resolve()
             if not path_to_orig.exists():
                 raise Util.CertoraUserInputError(f"Original file '{path_to_orig}' for manual mutations does not exist")
-            mutants_location = Path(mutant[MConstants.MUTANTS_LOCATION]).resolve()
+            mutants_location = Path(mutant[MConstants.MUTANTS_LOCATION])
             if mutants_location.is_dir():
-                MutateApp.add_dir_to_mutants(ret_mutants, mutants_location, file_to_mutate)
+                self.add_dir_to_mutants(ret_mutants, mutants_location, file_to_mutate)
             elif mutants_location.is_file():
-                MutateApp.add_file_to_mutants(ret_mutants, mutants_location, file_to_mutate)
+                self.add_file_to_mutants(ret_mutants, mutants_location, file_to_mutate)
             else:
                 raise Util.CertoraUserInputError(f"{mutants_location} not a valid file or directory")
         return ret_mutants
 
+    def get_universal_mutator_mutants(self) -> List[Mutant]:
+        """
+        Get manual mutations from universal_mutator attribute
+
+        Returns:
+        - A list of Mutant objects representing the found manual mutations.
+
+        Raises:
+        - `CertoraUserInputError`: If the mutation configuration file does not exist.
+        """
+
+        ret_mutants: List[Mutant] = []
+        assert self.universal_mutator, "get_universal_mutator_mutants: self.universal_mutator"
+        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])
+            run_universal_mutator(file_to_mutate, mutants_location)
+            self.add_dir_to_mutants(ret_mutants, mutants_location, file_to_mutate)
+        return ret_mutants
+
     def verify_orig_build(self) -> None:
         if self.orig_run:  # if orig run exists we will not try to build again
             return
@@ -1252,7 +1372,8 @@ class MutateApp:
         if self.prover_version:
             certora_args.extend(["--prover_version", self.prover_version])
 
-        certora_args.extend(["--disable_local_typechecking"])
+        if not self.is_soroban_run():
+            certora_args.extend(["--disable_local_typechecking"])
         mutation_logger.debug(f"Running the Prover: {certora_args}")
         try:
             certora_run_result = run_certora(certora_args)
@@ -1326,11 +1447,17 @@ class MutateApp:
         all_mutants_results: List[MutantJobWithResults] = []
         for mutant_job in mutants_jobs:
             mutant_link = mutant_job.link
-
-            mutant_run_results = self.get_results(mutant_link, fetcher)
-            if mutant_run_results is None:
+            if not mutant_link:
+                return None
+            try:
+                mutant_run_results = self.get_results(mutant_link, fetcher)
+            except Util.BadMutationError:
+                # we do not want to abort the mutation testing all together just because Prover failed.
+                # Some mutants may compile but fail during runtime. We just should ignore them in the final report
+                mutant_job.success = False
+                continue
+            if not mutant_run_results:
                 return None
-
             mutant_results = MutantJobWithResults(mutant_job, mutant_run_results)
 
             all_mutants_results.append(mutant_results)
@@ -1578,7 +1705,7 @@ class MutateApp:
             raise Util.ImplementationError("Could not get progress object")
         top_level_rules = get_top_level_rules(progress_json)
         if top_level_rules is None:
-            raise Util.ImplementationError("Could not get tree view object")
+            raise Util.BadMutationError("Could not get tree view object")
         rule_results = []
 
         for rule in top_level_rules: