certora-cli-beta-mirror 7.30.0__py3-none-any.whl → 7.31.0__py3-none-any.whl

certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

@@ -25,8 +25,9 @@ from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerColle
 from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
 from CertoraProver.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
 from CertoraProver.Compiler.CompilerCollectorVy import CompilerCollectorVy, CompilerLangVy
-from Shared.certoraUtils import match_path_to_mapping_key, remove_file, get_certora_config_dir
+from Shared.certoraUtils import remove_file, get_certora_config_dir
 from CertoraProver.certoraContextClass import CertoraContext
+import CertoraProver.certoraContext as Ctx
 
 # logger for running the Solidity compiler and reporting any errors it emits
 compiler_logger = logging.getLogger("compiler")
@@ -42,8 +43,16 @@ def get_relevant_compiler(contract_file_path: Path, context: CertoraContext) ->
 
     if contract_file_path.is_absolute():
         contract_file_path = Path(os.path.relpath(contract_file_path, Path.cwd()))
+
+    # If the contract file is in the sources directory, we want to use the relative path from the "cwd" in the source tree.
+    if Util.get_certora_sources_dir() in contract_file_path.parents:
+        cwd_in_source = Util.get_certora_sources_dir() / context.cwd_rel_in_sources
+        contract_file_path = Path(os.path.relpath(contract_file_path, cwd_in_source))
+
     if context.compiler_map:
-        match = match_path_to_mapping_key(contract_file_path, context.compiler_map)
+        match = Ctx.get_map_attribute_value(context, contract_file_path, 'compiler')
+        assert isinstance(match, str), (f"In the attribute compiler_map, {contract_file_path} expected to be matched "
+                                        f"to a string, {match} is of type {type(match)} not a string")
         if match:
             return match
         else:

certora_cli/CertoraProver/certoraBuild.py

@@ -450,8 +450,12 @@ def convert_pathname_to_posix(json_dict: Dict[str, Any], entry: str, smart_contr
             if path_obj.is_file():
                 json_dict_posix_paths[path_obj.as_posix()] = json_dict[entry][file_path]
             else:
+                json_dict_str = str(json_dict)
+                # protecting against long strings
+                if len(json_dict_str) > 200:
+                    json_dict_str = json_dict_str[:200] + '...'
                 fatal_error(compiler_logger, f"The path of the source file {file_path}"
-                                             f"in the standard json file {json_dict} does not exist")
+                                             f"in the standard json file {json_dict_str} does not exist")
         json_dict[entry] = json_dict_posix_paths
 
 
@@ -1361,46 +1365,48 @@ class CertoraBuildGenerator:
 
         return bytecode
 
-    def _handle_via_ir(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if not self.context.solc_via_ir_map and not self.context.solc_via_ir:
-            return
-        if self.context.solc_via_ir_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_via_ir_map)
-            if match:
-                settings_dict["viaIR"] = match
-        elif self.context.solc_via_ir:
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_via_ir')
+        assert isinstance(match, (bool, type(None))), f"Expected solc_via_ir to be bool or None, got {type(match)}"
+        return bool(match)
+
+    def get_solc_evm_version_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_evm_version')
+        assert isinstance(match, (str, type(None))), f"Expected solc_evm_version to be string or None, got {type(match)}"
+        return match
+
+    def get_solc_optimize_value(self, contract_file_path: Path) -> Optional[str]:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_optimize')
+        assert isinstance(match, (str, type(None))), f"Expected solc_optimize to be string or None, got {type(match)}"
+        return match
+
+    def _handle_via_ir(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_solc_via_ir_value(contract_file_path):
             settings_dict["viaIR"] = True
 
-    def _handle_evm_version(self, contract_file_path: str, settings_dict: Dict[str, Any]) -> None:
-        if self.context.solc_evm_version_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_evm_version_map)
-            if match:
-                settings_dict["evmVersion"] = match
-        elif self.context.solc_evm_version:
-            settings_dict["evmVersion"] = self.context.solc_evm_version
+    def _handle_evm_version(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        match = self.get_solc_evm_version_value(contract_file_path)
+        if match:
+            settings_dict["evmVersion"] = match
 
-    def _handle_optimize(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _handle_optimize(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                          compiler_collector: CompilerCollector) -> None:
         """
         @param contract_file_path: the contract that we are working on
         @param settings_dict: data structure for sending to the solc compiler
         """
-        if self.context.solc_optimize_map:
-            match = Util.match_path_to_mapping_key(Path(contract_file_path), self.context.solc_optimize_map)
-            if match and int(match) > 0:
-                settings_dict["optimizer"] = {"enabled": True}
-                settings_dict["optimizer"]['runs'] = int(match)
-        elif self.context.solc_optimize:
+        match = self.get_solc_optimize_value(contract_file_path)
+        if match:
             settings_dict["optimizer"] = {"enabled": True}
-            if int(self.context.solc_optimize) > 0:
-                settings_dict["optimizer"]['runs'] = int(self.context.solc_optimize)
+            if int(match) > 0:
+                settings_dict["optimizer"]['runs'] = int(match)
 
         # 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:
+            if not self.context.strict_solc_optimizer and self.get_solc_via_ir_value(contract_file_path):
                 # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
                 # full inliner step removed
                 solc0_8_26_to_0_8_30 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
@@ -1433,6 +1439,8 @@ class CertoraBuildGenerator:
                     raise Util.CertoraUserInputError(err_msg)
                 elif minor < 6 or (minor == 6 and patch < 7):
                     raise Util.CertoraUserInputError(err_msg)
+                elif self.context.yul_optimizer_steps:
+                    yul_optimizer_steps = self.context.yul_optimizer_steps
                 elif (minor == 6 and patch >= 7) or (minor == 7 and 0 <= patch <= 1):
                     yul_optimizer_steps = solc0_6_7_to_0_7_1
                 elif minor == 7 and 2 <= patch <= 5:
@@ -1470,7 +1478,7 @@ class CertoraBuildGenerator:
                 for opt_pass in self.context.disable_solc_optimizers:
                     settings_dict["optimizer"]["details"][opt_pass] = False
 
-    def _fill_codegen_related_options(self, contract_file_path: str, settings_dict: Dict[str, Any],
+    def _fill_codegen_related_options(self, contract_file_path: Path, settings_dict: Dict[str, Any],
                                       compiler_collector: CompilerCollector) -> None:
         """
         Fills options that control how we call solc and affect the bytecode in some way
@@ -1551,7 +1559,7 @@ class CertoraBuildGenerator:
                 }
             }
 
-        self._fill_codegen_related_options(contract_file_as_provided, settings_dict, compiler_collector)
+        self._fill_codegen_related_options(Path(contract_file_as_provided), settings_dict, compiler_collector)
 
         result_dict = {"language": compiler_collector_lang.name, "sources": sources_dict, "settings": settings_dict}
         # debug_print("Standard json input")
@@ -2286,7 +2294,7 @@ class CertoraBuildGenerator:
 
         if compiler_lang == CompilerLangSol():
             settings_dict: Dict[str, Any] = {}
-            self._fill_codegen_related_options(build_arg_contract_file, settings_dict,
+            self._fill_codegen_related_options(Path(build_arg_contract_file), settings_dict,
                                                compiler_collector_for_contract_file)
             solc_optimizer_on, solc_optimizer_runs = self.solc_setting_optimizer_runs(settings_dict)
             solc_via_ir = self.solc_setting_via_ir(settings_dict)
@@ -2416,7 +2424,7 @@ class CertoraBuildGenerator:
                 # if no function finder mode set, determine based on viaIR enabled or not:
                 if self.context.function_finder_mode is None:
                     # in via-ir, should not compress
-                    if self.context.solc_via_ir:
+                    if self.get_solc_via_ir_value(Path(contract_file)):
                         should_compress = False
                     else:
                         should_compress = True
@@ -3614,7 +3622,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
 
         try:
             if overwrite:
-                # expecting target path to exist.
+                # expecting the target path to exist.
                 if target_path.exists():
                     build_logger.debug(f"Overwriting {target_path} by copying from {source_path}")
                 else:
@@ -3632,7 +3640,7 @@ def build_source_tree(sources: Set[Path], context: CertoraContext, overwrite: bo
     cwd_file_path.parent.mkdir(parents=True, exist_ok=True)
     cwd_file_path.touch()
 
-    #  the empty file .project_directory is written in the source tree to denote the projecct directory
+    #  the empty file .project_directory is written in the source tree to denote the project directory
     rust_proj_dir = getattr(context, 'rust_project_directory', None)
     if rust_proj_dir:
         proj_dir_parent_relative = os.path.relpath(rust_proj_dir, os.getcwd())
@@ -3683,8 +3691,9 @@ def build_from_scratch(context: CertoraContext,
 
         # add to cache also source files that were found in the SDCs (e.g., storage extensions)
         paths_set = sdc.all_contract_files
-        for p in context.files:
-            paths_set.add(Path(p).absolute())
+        for f in context.files:
+            path = f.split(':')[0]  # `f` is either 'path/to/file.sol' or 'path/to/file.sol:ContractName'
+            paths_set.add(Path(path).absolute())
 
         # the contract files in SDCs are relative to .certora_sources. Which isn't good for us here.
         # Need to be relative to original paths
@@ -3724,8 +3733,7 @@ def build_from_scratch(context: CertoraContext,
 
 def build_from_cache_or_scratch(context: CertoraContext,
                                 certora_build_generator: CertoraBuildGenerator,
-                                certora_verify_generator: CertoraVerifyGenerator,
-                                certora_build_cache_manager: CertoraBuildCacheManager) \
+                                certora_verify_generator: CertoraVerifyGenerator) \
         -> Tuple[bool, bool, CachedFiles]:
     """
     Builds either from cache (fast path) or from scratch (slow path)
@@ -3742,10 +3750,10 @@ def build_from_cache_or_scratch(context: CertoraContext,
                                           False)
         return cache_hit, False, cached_files
 
-    build_cache_applicable = certora_build_cache_manager.cache_is_applicable(context)
+    build_cache_applicable = CertoraBuildCacheManager.cache_is_applicable(context)
 
     if not build_cache_applicable:
-        build_cache_disabling_options = certora_build_cache_manager.cache_disabling_options(context)
+        build_cache_disabling_options = CertoraBuildCacheManager.cache_disabling_options(context)
         build_logger.warning("Requested to enable the build cache, but the build cache is not applicable "
                              f"to this run because of the given options: {build_cache_disabling_options}")
         cached_files = build_from_scratch(context, certora_build_generator,
@@ -3753,7 +3761,7 @@ def build_from_cache_or_scratch(context: CertoraContext,
                                           False)
         return cache_hit, False, cached_files
 
-    cached_files = certora_build_cache_manager.build_from_cache(context)
+    cached_files = CertoraBuildCacheManager.build_from_cache(context)
     # if no match, will rebuild from scratch
     if cached_files is not None:
         # write to .certora_build.json
@@ -3792,7 +3800,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
     try:
         input_config = InputConfig(context)
-
+        context.main_cache_key = CertoraBuildCacheManager.get_main_cache_key(context)
         # Create generators
         certora_build_generator = CertoraBuildGenerator(input_config, context)
 
@@ -3808,12 +3816,9 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
             else:
                 Ctx.run_local_spec_check(False, context)
 
-        certora_build_cache_manager = CertoraBuildCacheManager()
-
         cache_hit, build_cache_enabled, cached_files = build_from_cache_or_scratch(context,
                                                                                    certora_build_generator,
-                                                                                   certora_verify_generator,
-                                                                                   certora_build_cache_manager)
+                                                                                   certora_verify_generator)
 
         # avoid running the same test over and over again for each split run, context.split_rules is true only for
         # the first run and is set to [] for split runs
@@ -3833,7 +3838,7 @@ def build(context: CertoraContext, ignore_spec_syntax_check: bool = False) -> No
 
         # save in build cache
         if not cache_hit and build_cache_enabled and cached_files.may_store_in_build_cache:
-            certora_build_cache_manager.save_build_cache(context, cached_files)
+            CertoraBuildCacheManager.save_build_cache(context, cached_files)
 
         certora_verify_generator.update_certora_verify_struct(True)
         certora_verify_generator.dump()  # second dump with properly rooted specs

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)

certora_cli/CertoraProver/certoraBuildRust.py

@@ -51,6 +51,7 @@ def build_rust_app(context: CertoraContext) -> None:
         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)
@@ -102,7 +103,7 @@ def add_solana_files_to_sources(context: CertoraContext, sources: Set[Path]) ->
 
 
 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"]
 
     if hasattr(context, 'rust_project_directory'):

certora_cli/CertoraProver/certoraCloudIO.py

@@ -760,42 +760,20 @@ class CloudVerification:
                           Util.get_configuration_layout_data_file(),
                           Util.get_build_dir() / Path(self.context.files[0]).name]
 
+            if Util.get_debug_log_file().exists():
+                files_list.append(Util.get_debug_log_file())
+
             if Util.get_certora_sources_dir().exists():
                 files_list.append(Util.get_certora_sources_dir())
 
             if hasattr(self.context, 'build_script') and self.context.build_script:
-                result = compress_files(self.logZipFilePath, Util.get_debug_log_file(),
-                                        short_output=Ctx.is_minimal_cli_output(self.context))
-
-                if not result:
-                    return False
-                files_list.append(self.logZipFilePath)
-
-                # Create a .RustExecution file to classify zipInput as a rust source code
-                rust_execution_file = Util.get_build_dir() / ".RustExecution"
-                rust_execution_file.touch(exist_ok=True)
-                files_list.append(rust_execution_file)
-
                 if attr_file := getattr(self.context, 'rust_logs_stdout', None):
                     files_list.append(Util.get_build_dir() / Path(attr_file).name)
                 if attr_file := getattr(self.context, 'rust_logs_stderr', None):
                     files_list.append(Util.get_build_dir() / Path(attr_file).name)
 
-                result = compress_files(self.ZipFilePath, *files_list,
-                                        short_output=Ctx.is_minimal_cli_output(self.context))
-
-            elif Attrs.is_solana_app() or Attrs.is_soroban_app():
-                for file in self.context.files:
-                    files_list.append(Path(file))
-
-                result = compress_files(self.ZipFilePath, *files_list,
-                                        short_output=Ctx.is_minimal_cli_output(self.context))
-            else:
-                raise Util.CertoraUserInputError(
-                    'When running rust application, context should either have attribute "rust_executables" '
-                    'provided by build_script execution, '
-                    'or either is_solana_app(), is_soroban_app() should be set to True'
-                )
+            result = compress_files(self.ZipFilePath, *files_list,
+                                    short_output=Ctx.is_minimal_cli_output(self.context))
 
         else:
             # Zip the log file first separately and again with the rest of the files, so it will not be decompressed
@@ -953,6 +931,8 @@ class CloudVerification:
         for i in range(self.verification_request_retries):
             try:
                 response = requests.post(verify_url, json=auth_data, headers=headers, timeout=60)
+                cloud_logger.debug(f"\n\n=================\n\nresponse - Status Code: {response.status_code}\n\n"
+                                   f"Headers:\n {response.headers}\n\nText:\n {response.text}\n\n=================\n\n")
                 if response is None:
                     continue
                 status = response.status_code

certora_cli/CertoraProver/certoraCollectConfigurationLayout.py

@@ -25,12 +25,13 @@ sys.path.insert(0, str(scripts_dir_path))
 import CertoraProver.certoraContextAttributes as Attrs
 from CertoraProver.certoraCollectRunMetadata import RunMetaData, MetadataEncoder
 import Shared.certoraUtils as Utils
+from typing import List
 
 
 class MainSection(Enum):
     GENERAL = "GENERAL"
+    OPTIONS = "OPTIONS"
     SOLIDITY_COMPILER = "SOLIDITY_COMPILER"
-    GIT = "GIT"
     NEW_SECTION = "NEW_SECTION"
 
 
@@ -47,13 +48,11 @@ class InnerContent:
     content: Any
     doc_link: str = ''
     tooltip: str = ''
-    unsound: str = 'false'
+    unsound: bool = False
 
     def __post_init__(self) -> None:
         if isinstance(self.content, bool):
             self.content = 'true' if self.content else 'false'
-        if isinstance(self.unsound, bool):
-            self.unsound = 'true' if self.unsound else 'false'
 
 
 @dataclasses.dataclass
@@ -65,6 +64,7 @@ class CardContent:
 
 DOC_LINK_PREFIX = 'https://docs.certora.com/en/latest/docs/'
 GIT_ATTRIBUTES = ['origin', 'revision', 'branch', 'dirty']
+ARG_LIST_ATTRIBUTES = ['prover_args', 'java_args']
 
 
 class AttributeJobConfigData:
@@ -73,13 +73,13 @@ class AttributeJobConfigData:
     This should be added to the AttributeDefinition and configured for every new attribute
     presented in the Rule report.
 
-    Note: Attributes which do not contain specific information will be assigned as a Flag in the General main section!
+    Note: Attributes that do not contain specific information will be presented in the OPTIONS main section!
 
     arguments:
     - main_section : MainSection -- the main section inside the config tab
-        default: MainSection.GENERAL
-    - subsection : str -- the subsection within the main_section (e.g Flags)
-        default: Flags
+        default: MainSection.OPTIONS
+    - subsection : str -- the subsection within the main_section
+        default: None - they will be presented inside the OPTIONS card
     - doc_link : Optional[str] -- a link to the Documentation page of this attribute (if exists)
         default: 'https://docs.certora.com/en/latest/docs/' + Solana/EVM path + #<attribute_name>
     - tooltip : Optional[str] -- a description of this attribute to present in the config tab
@@ -88,7 +88,7 @@ class AttributeJobConfigData:
         default: False
     """
 
-    def __init__(self, main_section: MainSection = MainSection.GENERAL, subsection: str = '',
+    def __init__(self, main_section: MainSection = MainSection.OPTIONS, subsection: str = '',
                  doc_link: Optional[str] = '', tooltip: Optional[str] = '', unsound: bool = False):
         self.main_section = main_section
         self.subsection = subsection
@@ -201,6 +201,40 @@ def create_or_get_card_content(output: list[CardContent], name: str) -> CardCont
     return main_section
 
 
+def split_and_sort_arg_list_value(args_list: List[str]) -> List[str]:
+    """
+    Splits a unified CLI argument list of strings into a sorted list of flag+value groups.
+    This is useful mainly for --prover_args and --java_args.
+
+    For example:
+    "-depth 15 -adaptiveSolverConfig false" → ["-adaptiveSolverConfig false", "-depth 15"]
+
+    Assumes each flag starts with '-' and its value follows immediately, if exists.
+    Lines are sorted alphabetically.
+    """
+    unified_args = ''.join(args_list)
+
+    if not unified_args.strip():
+        return []
+
+    lines: List[str] = []
+    tokens = unified_args.split()
+    curr_line = ""
+
+    for token in tokens:
+        if token.startswith('-'):
+            if curr_line:
+                lines.append(curr_line)
+            curr_line = token
+        else:
+            curr_line += f" {token}"
+
+    if curr_line:
+        lines.append(curr_line)
+
+    return sorted(lines)
+
+
 def create_inner_content(name: str, content_type: ContentType, value: Any, doc_link: str,
                          config_data: AttributeJobConfigData) -> InnerContent:
     return InnerContent(
@@ -209,7 +243,7 @@ def create_inner_content(name: str, content_type: ContentType, value: Any, doc_l
         content=value,
         doc_link=doc_link,
         tooltip=config_data.tooltip or '',
-        unsound='true' if config_data.unsound else 'false'
+        unsound=config_data.unsound
     )
 
 
@@ -260,35 +294,23 @@ def collect_attribute_configs(metadata: dict) -> list[CardContent]:
             )
             continue
 
-        # Find or create the subsection (if it exists)
+        # Find or create the subsection (if it doesn't exist)
         if isinstance(attr_value, list):
-            current_section: Any = main_section
             content_type = ContentType.SIMPLE
+            if attr_name in ARG_LIST_ATTRIBUTES:
+                attr_value = split_and_sort_arg_list_value(attr_value)
 
         elif isinstance(attr_value, dict):
-            current_section = main_section
             content_type = ContentType.COMPLEX
             attr_value = [
                 create_inner_content(key, ContentType.FLAG, value, doc_link, config_data)
                 for key, value in attr_value.items()
             ]
         else:
-            # this attribute is a value attribute without a subsection, it will be placed in flags.
-            subsection_key = config_data.subsection.lower() if config_data.subsection else 'flags'
-            current_section = next((section for section in main_section.content
-                                    if section.inner_title == subsection_key), None)
-            if current_section is None:
-                current_section = InnerContent(
-                    inner_title=subsection_key,
-                    content_type=ContentType.COMPLEX.value,
-                    content=[]
-                )
-                main_section.content.append(current_section)
-
             content_type = ContentType.FLAG
 
         # Update the current section with attribute details
-        current_section.content.append(
+        main_section.content.append(
             create_inner_content(attr_name, content_type, attr_value, doc_link, config_data)
         )
 
@@ -300,37 +322,23 @@ def collect_run_config_from_metadata(attributes_configs: list[CardContent], meta
     Adding CLI and Git configuration from metadata
     """
 
-    # Define a mapping of metadata attributes to their keys in general_section
-    metadata_mappings = {
-        'CLI Version': metadata.get('CLI_version'),
-        'Verify': metadata.get('conf', {}).get('verify'),
-    }
-
     general_section = create_or_get_card_content(attributes_configs, MainSection.GENERAL.value.lower())
 
-    # Add metadata attributes dynamically if they exist
-    for key, value in metadata_mappings.items():
-        if value:
-            general_section.content.append(InnerContent(
-                inner_title=key,
-                content_type=ContentType.FLAG.value,
-                content=value,
-            ))
+    if cli_version := metadata.get('CLI_version'):
+        general_section.content.append(InnerContent(
+            inner_title='CLI Version',
+            content_type=ContentType.FLAG.value,
+            content=cli_version,
+        ))
 
-    # Adding GIT configuration from metadata only if attributes are found
-    git_content = []
     for attr in GIT_ATTRIBUTES:
         if attr_value := metadata.get(attr):
-            git_content.append(InnerContent(
+            general_section.content.append(InnerContent(
                 inner_title=attr,
                 content_type=ContentType.FLAG.value,
                 content=attr_value,
             ))
 
-    if git_content:
-        git_section = create_or_get_card_content(attributes_configs, MainSection.GIT.value.lower())
-        git_section.content = git_content
-
     return attributes_configs
 
 
@@ -338,14 +346,17 @@ def sort_configuration_layout(data: list[CardContent]) -> list[CardContent]:
     """
     Sorts a configuration layout:
     - Top-level sorted by 'card_title'
-    - Nested content sorted by 'inner_title', with 'Verify' first
+    - Nested content sorted by 'inner_title', with 'verify' first
     """
     priority = {
-        "Verify": 0,
+        # Priorities for top-level cards
         "general": 0,
+        "files": 1,
+        "options": 2,
+        # Top level items inside their respective cards
+        "verify": 0,
         "solc": 0,
-        "CLI Version": 1,
-        "flags": 2
+        "CLI Version": 0
     }
 
     def inner_sort_key(item: Any) -> Any:

certora_cli/CertoraProver/certoraConfigIO.py

@@ -17,6 +17,7 @@ import json5
 import logging
 from pathlib import Path
 from typing import Dict, Any
+from collections import OrderedDict
 
 import CertoraProver.certoraContext as Ctx
 import CertoraProver.certoraContextAttributes as Attrs
@@ -75,7 +76,7 @@ def read_from_conf_file(context: CertoraContext) -> None:
 
     try:
         with conf_file_path.open() as conf_file:
-            context.conf_file_attr = json5.load(conf_file, allow_duplicate_keys=False)
+            context.conf_file_attr = json5.load(conf_file, allow_duplicate_keys=False, object_pairs_hook=OrderedDict)
             try:
                 check_conf_content(context)
             except Util.CertoraUserInputError as e: