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

certora_cli/CertoraProver/certoraCloudIO.py

@@ -47,6 +47,7 @@ import logging
 cloud_logger = logging.getLogger("cloud")
 
 MAX_FILE_SIZE = 25 * 1024 * 1024
+SOLANA_MAX_FILE_SIZE = 2 * MAX_FILE_SIZE
 NO_OUTPUT_LIMIT_MINUTES = 15
 MAX_POLLING_TIME_MINUTES = 150
 LOG_READ_FREQUENCY = 10
@@ -69,6 +70,16 @@ Response = requests.models.Response
 
 FEATURES_REPORT_FILE = Path("featuresReport.json")
 
+class EcoEnum(Util.NoValEnum):
+    EVM = Util.auto()
+    SOROBAN = Util.auto()
+    SOLANA = Util.auto()
+
+class ProductEnum(Util.NoValEnum):
+    PROVER = Util.auto()
+    RANGER = Util.auto()
+    SOPHY = Util.auto()
+
 
 class TimeError(Exception):
     """A custom exception used to report on time elapsed errors"""
@@ -264,7 +275,9 @@ def compress_files(zip_file_path: Path, *resource_paths: Path, short_output: boo
                     cloud_logger.error(f"{GENERAL_ERR_PREFIX}"  f"Could not compress {path}")
                     return False
 
-    if zip_file_path.stat().st_size > MAX_FILE_SIZE:
+    # Solana binary files can become heavy, thus we need to increase size limit.
+    max_file_size = MAX_FILE_SIZE if not Attrs.is_rust_app() else SOLANA_MAX_FILE_SIZE
+    if zip_file_path.stat().st_size > max_file_size:
         cloud_logger.error(f"{GENERAL_ERR_PREFIX} Max 25MB file size exceeded.")
         return False
 
@@ -592,43 +605,25 @@ class CloudVerification:
 
         jar_settings = Ctx.collect_jar_args(self.context)
 
-        if Attrs.is_solana_app():
-            # We need to strip "../" path component from all file paths because
-            # unzip will also do that.
-            solana_jar_settings = []
-            if hasattr(self.context, 'build_script') and self.context.build_script:
-                solana_jar_settings.append(Path(self.context.rust_executables).name)
+        if Attrs.is_rust_app():
+            rust_jar_settings = [Path(self.context.files[0]).name]
 
-            else:
-                for file in self.context.files:
-                    solana_jar_settings.append(file.split('../')[-1])
+            if Attrs.is_solana_app():
+                def paths_in_source_dir(attr_values: List[str]) -> str:
+                    cwd_rel_in_sources = Util.get_certora_sources_dir() / self.context.cwd_rel_in_sources
+                    values: list[str] = \
+                        [os.path.relpath(cwd_rel_in_sources / value, Util.get_build_dir()) for value in attr_values]
+                    return ','.join(values)
 
-            is_file = False
-            for arg in jar_settings:
-                if is_file:
-                    solana_jar_settings.append(arg.split('../')[-1])
-                    is_file = False
-                else:
-                    solana_jar_settings.append(arg)
+                if self.context.solana_summaries:
+                    rust_jar_settings.append('-solanaSummaries')
+                    rust_jar_settings.append(paths_in_source_dir(self.context.solana_summaries))
 
-                if arg == '-solanaInlining':
-                    is_file = True
-                elif arg == '-solanaSummaries':
-                    is_file = True
-            auth_data["jarSettings"] = solana_jar_settings
-        elif Attrs.is_soroban_app():
-            # We need to strip "../" path component from all file paths because
-            # unzip will also do that.
-            soroban_jar_settings = []
-            # not needed - should be in files
-            if hasattr(self.context, 'build_script') and self.context.build_script:
-                soroban_jar_settings.append(Path(self.context.rust_executables).name)
-            else:
-                for file in self.context.files:
-                    soroban_jar_settings.append(file.split('../')[-1])
-            for arg in jar_settings:
-                soroban_jar_settings.append(arg)
-            auth_data["jarSettings"] = soroban_jar_settings
+                if self.context.solana_inlining:
+                    rust_jar_settings.append('-solanaInlining')
+                    rust_jar_settings.append(paths_in_source_dir(self.context.solana_inlining))
+
+            auth_data["jarSettings"] = rust_jar_settings + jar_settings
         else:
             auth_data["jarSettings"] = jar_settings
 
@@ -646,6 +641,20 @@ class CloudVerification:
 
         auth_data["useLatestFe"] = self.context.fe_version == str(Util.FeValue.LATEST)
 
+        if Attrs.is_solana_app():
+            auth_data["ecosystem"] = EcoEnum.SOLANA.name
+        elif Attrs.is_soroban_app():
+            auth_data["ecosystem"] = EcoEnum.SOROBAN.name
+        else:
+            auth_data["ecosystem"] = EcoEnum.EVM.name
+
+        if Attrs.is_ranger_app():
+            auth_data["product"] = ProductEnum.RANGER.name
+        elif Attrs.is_sophy_app():
+            auth_data["product"] = ProductEnum.SOPHY.name
+        else:
+            auth_data["product"] = ProductEnum.PROVER.name
+
         if Attrs.is_evm_app() and self.context.cache is not None:
             auth_data["toolSceneCacheKey"] = self.context.cache
 
@@ -747,7 +756,10 @@ class CloudVerification:
             result = compress_files(self.ZipFilePath, *paths,
                                     short_output=Ctx.is_minimal_cli_output(self.context))
         elif Attrs.is_rust_app():
-            files_list = [Util.get_certora_metadata_file(), Util.get_configuration_layout_data_file()]
+            files_list = [Util.get_certora_metadata_file(),
+                          Util.get_configuration_layout_data_file(),
+                          Util.get_build_dir() / Path(self.context.files[0]).name]
+
             if Util.get_certora_sources_dir().exists():
                 files_list.append(Util.get_certora_sources_dir())
 
@@ -759,18 +771,11 @@ class CloudVerification:
                     return False
                 files_list.append(self.logZipFilePath)
 
-                files_list.append(Util.get_build_dir() / Path(self.context.rust_executables).name)
-
                 # 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)
 
-                additional_files = (getattr(self.context, 'solana_inlining', None) or []) + \
-                                   (getattr(self.context, 'solana_summaries', None) or [])
-                for file in additional_files:
-                    files_list.append(Util.get_build_dir() / Path(file).name)
-
                 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):
@@ -779,29 +784,10 @@ class CloudVerification:
                 result = compress_files(self.ZipFilePath, *files_list,
                                         short_output=Ctx.is_minimal_cli_output(self.context))
 
-            elif Attrs.is_solana_app():
-                # We zip the ELF files and the two configuration files
-                jar_args = Ctx.collect_jar_args(self.context)
-
+            elif Attrs.is_solana_app() or Attrs.is_soroban_app():
                 for file in self.context.files:
                     files_list.append(Path(file))
-                is_file = False
-                for arg in jar_args:
-                    if is_file:
-                        files_list.append(Path(arg))
-                        is_file = False
-
-                    if arg == '-solanaInlining':
-                        is_file = True
-                    elif arg == '-solanaSummaries':
-                        is_file = True
-                result = compress_files(self.ZipFilePath, *files_list,
-                                        short_output=Ctx.is_minimal_cli_output(self.context))
 
-            elif Attrs.is_soroban_app():
-                # We zip the wat file
-                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:
@@ -829,6 +815,8 @@ class CloudVerification:
         Util.flush_stdout()
         if not result:
             return False
+        if self.context.test == str(Util.TestValue.CHECK_ZIP):
+            raise Util.TestResultsReady(self.ZipFilePath)
 
         cloud_logger.debug("Uploading files...")
         if self.upload(self.presigned_url, self.ZipFilePath):
@@ -866,6 +854,7 @@ class CloudVerification:
             return False
 
         file_upload_success = self.__compress_and_upload_zip_files()
+
         if not file_upload_success:
             return False
 

certora_cli/CertoraProver/certoraCollectConfigurationLayout.py

@@ -12,10 +12,10 @@
 #
 #     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 dataclasses
 import json
 from enum import Enum
-from typing import Optional, Dict, Any
+from typing import Optional, Any
 from pathlib import Path
 import sys
 
@@ -31,21 +31,40 @@ class MainSection(Enum):
     GENERAL = "GENERAL"
     SOLIDITY_COMPILER = "SOLIDITY_COMPILER"
     GIT = "GIT"
-    FILES = "FILES"
-    LINKS = "LINKS"
-    PACKAGES = "PACKAGES"
-    METADATA = "METADATA"
+    NEW_SECTION = "NEW_SECTION"
+
+
+class ContentType(Enum):
+    SIMPLE = "SIMPLE"
+    COMPLEX = "COMPLEX"
+    FLAG = "FLAG"
+
+
+@dataclasses.dataclass
+class InnerContent:
+    inner_title: str
+    content_type: str
+    content: Any
+    doc_link: str = ''
+    tooltip: str = ''
+    unsound: str = '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'
 
-class FlagType(Enum):
-    VALUE_FLAG = "VALUE"
-    LIST_FLAG = "LIST"
-    MAP_FLAG = "MAP"
+
+@dataclasses.dataclass
+class CardContent:
+    card_title: str
+    content_type: str
+    content: Any
 
 
 DOC_LINK_PREFIX = 'https://docs.certora.com/en/latest/docs/'
 GIT_ATTRIBUTES = ['origin', 'revision', 'branch', 'dirty']
-SPECIAL_MAIN_SECTIONS = ['files', 'links', 'packages']
 
 
 class AttributeJobConfigData:
@@ -87,18 +106,25 @@ class RunConfigurationLayout:
     configuration_layout : Dict -- An aggregated configuration for a specific run, nested by main section, subsection.
         Each leaf contains data about attribute value, type, documentation link and UI data.
     """
-    def __init__(self, configuration_layout: Dict[str, Any]):
+
+    configuration_layout: list[Any]
+
+    def __init__(self, configuration_layout: list[Any]):
         # Dynamically allocate class attributes from dict
-        for key, value in configuration_layout.items():
-            setattr(self, key, value)
+        self.configuration_layout = configuration_layout
 
     def __repr__(self) -> str:
-        return "\n".join(f"{key}: {value}" for key, value in self.__dict__.items())
+        try:
+            return json.dumps(self.configuration_layout, indent=2, sort_keys=True)
+        except TypeError:
+            # Fallback if something isn't serializable
+            return str(self.configuration_layout)
 
     @classmethod
-    def dump_file(cls, data: dict) -> None:
+    def dump_file(cls, data: list) -> None:
+        sorted_data = sort_configuration_layout(data)
         with Utils.get_configuration_layout_data_file().open("w+") as f:
-            json.dump(data, f, indent=4, sort_keys=True, cls=MetadataEncoder)
+            json.dump(sorted_data, f, indent=4, cls=MetadataEncoder)
 
     @classmethod
     def load_file(cls) -> dict:
@@ -110,12 +136,11 @@ class RunConfigurationLayout:
             raise
 
     def dump(self) -> None:
-        if self.__dict__:  # dictionary containing all the attributes defined for GitInfo
-            try:
-                self.dump_file(self.__dict__)
-            except Exception as e:
-                print(f"failed to write configuration layout file {Utils.get_configuration_layout_data_file()}\n{e}")
-                raise
+        try:
+            self.dump_file(self.configuration_layout)
+        except Exception as e:
+            print(f"Failed to write configuration layout file: {Utils.get_configuration_layout_data_file()}\n{e}")
+            raise
 
 
 def collect_configuration_layout() -> RunConfigurationLayout:
@@ -127,7 +152,7 @@ def collect_configuration_layout() -> RunConfigurationLayout:
         metadata = RunMetaData.load_file()
     except Exception as e:
         print(f"failed to load job metadata! cannot create a configuration layout file without metadata!\n{e}")
-        return RunConfigurationLayout(configuration_layout={})
+        return RunConfigurationLayout(configuration_layout=[])
 
     attributes_configs = collect_attribute_configs(metadata)
     configuration_layout = collect_run_config_from_metadata(attributes_configs, metadata)
@@ -154,89 +179,199 @@ def get_doc_link(attr) -> str:  # type: ignore
     return doc_link
 
 
-def collect_attribute_configs(metadata: dict) -> dict:
+def create_or_get_card_content(output: list[CardContent], name: str) -> CardContent:
+    """
+        Returns an existing CardContent by name or creates and appends a new one if it doesn't exist.
+        Card content type will always be complex in this case.
+        Args:
+            output (list[CardContent]): List of CardContent objects.
+            name (str): Title of the card to find or create.
+
+        Returns:
+            CardContent: The found or newly created CardContent.
+        """
+    main_section = next((section for section in output if section.card_title == name), None)
+    if main_section is None:
+        main_section = CardContent(
+            card_title=name,
+            content_type=ContentType.COMPLEX.value,
+            content=[]
+        )
+        output.append(main_section)
+    return main_section
+
+
+def create_inner_content(name: str, content_type: ContentType, value: Any, doc_link: str,
+                         config_data: AttributeJobConfigData) -> InnerContent:
+    return InnerContent(
+        inner_title=name,
+        content_type=content_type.value,
+        content=value,
+        doc_link=doc_link,
+        tooltip=config_data.tooltip or '',
+        unsound='true' if config_data.unsound else 'false'
+    )
+
+
+def collect_attribute_configs(metadata: dict) -> list[CardContent]:
+    """
+    Collects and organizes attribute configurations into a structured list of CardContent objects.
+
+    This function iterates through all available attributes defined, checks if relevant metadata is provided
+    for each attribute, and organizes the data into sections and subsections based on configuration rules.
+
+    Attributes are grouped under their respective main sections, with special handling for:
+    - Simple value attributes
+    - List and dictionary attributes
+    - Attributes requiring new sections (e.g., Files, Links, Packages)
+
+    Args:
+        metadata (dict): Metadata dictionary containing attribute values.
+
+    Returns:
+        list: A list of CardContent objects representing the structured configuration view,
+              ready for rendering or further processing.
+    """
     attr_list = Attrs.get_attribute_class().attribute_list()
-    output: Dict[str, Any] = {}
+    output: list[CardContent] = []
 
     for attr in attr_list:
         attr_name = attr.name.lower()
         if attr.config_data is None:
             continue
 
-        if metadata.get(attr_name) is None and metadata.get('conf', {}).get(attr_name) is None:
+        attr_value = metadata.get(attr_name) or metadata.get('conf', {}).get(attr_name)
+        if attr_value is None:
             continue
 
-        attr_value = metadata.get(attr_name) or metadata.get('conf', {}).get(attr_name)
         config_data: AttributeJobConfigData = attr.config_data
         doc_link = config_data.doc_link or get_doc_link(attr)
 
-        # Get or create the main section
+        # Find or create the main section
         main_section_key = config_data.main_section.value.lower()
-        main_section = output.setdefault(main_section_key, {})
+        main_section = create_or_get_card_content(output, main_section_key)
+
+        # Files, Links and Packages are special cases where the main section is the attribute itself
+        if main_section_key == MainSection.NEW_SECTION.value.lower():
+            main_section.card_title = attr_name
+            main_section.content_type = ContentType.SIMPLE.value
+            main_section.content.append(
+                create_inner_content(attr_name, ContentType.SIMPLE, attr_value, doc_link, config_data)
+            )
+            continue
 
-        # Get or create the subsection (if it exists) and flag_type
+        # Find or create the subsection (if it exists)
         if isinstance(attr_value, list):
-            # Files, Links and Packages are special cases where the main section is the attribute itself
-            if main_section_key in SPECIAL_MAIN_SECTIONS:
-                current_section = output
-                attr_name = main_section_key
-            else:
-                current_section = main_section
-
-            flag_type = FlagType.LIST_FLAG
+            current_section: Any = main_section
+            content_type = ContentType.SIMPLE
+
         elif isinstance(attr_value, dict):
             current_section = main_section
-            flag_type = FlagType.MAP_FLAG
+            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 = main_section.setdefault(subsection_key, {})
-            flag_type = FlagType.VALUE_FLAG
+            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[attr_name] = {
-            'value': attr_value,
-            'flag_type': flag_type.value.lower(),
-            'doc_link': doc_link,
-            'tooltip': config_data.tooltip,
-            'unsound': config_data.unsound
-        }
+        current_section.content.append(
+            create_inner_content(attr_name, content_type, attr_value, doc_link, config_data)
+        )
 
     return output
 
 
-def collect_run_config_from_metadata(attributes_configs: dict, metadata: dict) -> dict:
+def collect_run_config_from_metadata(attributes_configs: list[CardContent], metadata: dict) -> list[CardContent]:
     """
     Adding CLI and Git configuration from metadata
     """
-    metadata_section = attributes_configs.setdefault(MainSection.METADATA.value.lower(), {})
 
     # Define a mapping of metadata attributes to their keys in general_section
     metadata_mappings = {
-        'cli_version': metadata.get('CLI_version'),
-        'main_spec': metadata.get('main_spec'),
-        'solc_version': metadata.get('conf', {}).get('solc'),
-        'verify': metadata.get('conf', {}).get('verify'),
+        '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:
-            metadata_section[key] = {
-                'value': value,
-                'flag_type': FlagType.VALUE_FLAG.value,
-                'doc_link': '',
-                'tooltip': '',
-            }
-
-    # Adding GIT configuration from metadata
-    git_section = attributes_configs.setdefault(MainSection.GIT.value.lower(), {})
+            general_section.content.append(InnerContent(
+                inner_title=key,
+                content_type=ContentType.FLAG.value,
+                content=value,
+            ))
+
+    # Adding GIT configuration from metadata only if attributes are found
+    git_content = []
     for attr in GIT_ATTRIBUTES:
         if attr_value := metadata.get(attr):
-            git_section[attr] = {
-                'value': attr_value,
-                'flag_type': FlagType.MAP_FLAG.value,
-                'doc_link': '',
-                'tooltip': ''
-            }
+            git_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
+
+
+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
+    """
+    priority = {
+        "Verify": 0,
+        "general": 0,
+        "solc": 0,
+        "CLI Version": 1,
+        "flags": 2
+    }
+
+    def inner_sort_key(item: Any) -> Any:
+        if isinstance(item, CardContent):
+            title = item.card_title
+            return priority.get(title, 3), title.lower()
+        elif isinstance(item, InnerContent):
+            title = item.inner_title
+            return priority.get(title, 3), title.lower()
+        else:
+            return item
+
+    def sort_content(content: list[InnerContent]) -> list[InnerContent]:
+        sorted_content = []
+        for item in content:
+            if isinstance(item.content, list):
+                # Recurse into nested 'content'
+                item.content = sorted(item.content, key=inner_sort_key)
+            sorted_content.append(item)
+        return sorted(sorted_content, key=inner_sort_key)
+
+    # Sort top-level entries by 'card_title'
+    sorted_data = sorted(data, key=inner_sort_key)
+
+    # Sort nested 'content'
+    for section in sorted_data:
+        section.content = sort_content(section.content)
+
+    return sorted_data

certora_cli/CertoraProver/certoraCollectRunMetadata.py

@@ -12,7 +12,7 @@
 #
 #     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 dataclasses
 import json
 from typing import Any, Dict, List, Optional
 import subprocess
@@ -47,6 +47,8 @@ class MetadataEncoder(json.JSONEncoder):
     def default(self, obj: Any) -> Any:
         if isinstance(obj, set):
             return list(obj)
+        if dataclasses.is_dataclass(obj):
+            return dataclasses.asdict(obj)
         return json.JSONEncoder.default(self, obj)
 
 

certora_cli/CertoraProver/certoraConfigIO.py

@@ -75,9 +75,9 @@ def read_from_conf_file(context: CertoraContext) -> None:
 
     try:
         with conf_file_path.open() as conf_file:
-            conf_file_attr = json5.load(conf_file, allow_duplicate_keys=False)
+            context.conf_file_attr = json5.load(conf_file, allow_duplicate_keys=False)
             try:
-                check_conf_content(conf_file_attr, context)
+                check_conf_content(context)
             except Util.CertoraUserInputError as e:
                 raise Util.CertoraUserInputError(f"Error when reading {conf_file_path}: {str(e)}", e) from None
             context.conf_file = str(conf_file_path)
@@ -99,6 +99,7 @@ def handle_override_base_config(context: CertoraContext) -> None:
         with Path(context.override_base_config).open() as conf_file:
             try:
                 override_base_config_attrs = json5.load(conf_file, allow_duplicate_keys=False)
+                context.conf_file_attr = {**override_base_config_attrs, **context.conf_file_attr}
 
                 if 'override_base_config' in override_base_config_attrs:
                     raise Util.CertoraUserInputError("base config cannot include 'override_base_config'")
@@ -113,7 +114,7 @@ def handle_override_base_config(context: CertoraContext) -> None:
                     raise Util.CertoraUserInputError(f"{attr} appears in the base conf file {context.override_base_config} but is not a known attribute.")
 
 
-def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext) -> None:
+def check_conf_content(context: CertoraContext) -> None:
     """
     validating content read from the conf file
     Note: a command line definition trumps the definition in the file.
@@ -122,15 +123,15 @@ def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext)
     @param context: A namespace containing options from the command line, if any
     """
 
-    for option in conf_file_attr:
+    for option in context.conf_file_attr:
         if hasattr(context, option):
             val = getattr(context, option)
             if val is None or val is False:
-                setattr(context, option, conf_file_attr[option])
-            elif option != Attrs.EvmProverAttributes.FILES.get_conf_key() and val != conf_file_attr[option]:
+                setattr(context, option, context.conf_file_attr[option])
+            elif option != 'files' and val != context.conf_file_attr[option]:
                 cli_val = ' '.join(val) if isinstance(val, list) else str(val)
-                conf_val = ' '.join(conf_file_attr[option]) \
-                    if isinstance(conf_file_attr[option], list) else str(conf_file_attr[option])
+                conf_val = ' '.join(context.conf_file_attr[option]) \
+                    if isinstance(context.conf_file_attr[option], list) else str(context.conf_file_attr[option])
                 run_logger.warning(f"Note: attribute {option} value in CLI ({cli_val}) overrides value stored in conf"
                                    f" file ({conf_val})")
         else:
@@ -138,12 +139,10 @@ def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext)
 
     handle_override_base_config(context)
 
-    if Attrs.is_evm_app() and 'files' not in conf_file_attr and not context.project_sanity and not context.foundry:
+    if Attrs.is_evm_app() and not context.files and not context.project_sanity and not context.foundry:
         raise Util.CertoraUserInputError("Mandatory 'files' attribute is missing from the configuration")
+    context.files = context.conf_file_attr.get('files')
+    if Attrs.is_soroban_app() and not context.files and not context.build_script:
+        raise Util.CertoraUserInputError("'files' or 'build script' must be set for Soroban runs")
 
-    if Attrs.is_rust_app():
-        has_build_script = getattr(context, 'build_script', False)
-        if not has_build_script and 'files' not in conf_file_attr:
-            raise Util.CertoraUserInputError("Mandatory 'build_script' or 'files' attribute is missing from the configuration")
-
-    context.files = conf_file_attr.get('files')
+    context.files = context.conf_file_attr.get('files')