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

certora_cli/CertoraProver/certoraCloudIO.py

@@ -43,10 +43,10 @@ from tqdm import tqdm
 
 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 +69,17 @@ Response = requests.models.Response
 
 FEATURES_REPORT_FILE = Path("featuresReport.json")
 
+class EcoEnum(Util.NoValEnum):
+    EVM = Util.auto()
+    SOROBAN = Util.auto()
+    SOLANA = Util.auto()
+    SUI = Util.auto()
+
+class ProductEnum(Util.NoValEnum):
+    PROVER = Util.auto()
+    RANGER = Util.auto()
+    CONCORD = 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
 
@@ -574,7 +587,7 @@ class CloudVerification:
         """
 
         auth_data = {
-            "process": self.context.process, "runName": self.runName,
+            "runName": self.runName,
             "run_source": self.context.run_source,
             "group_id": self.context.group_id,
             "branch": self.context.prover_version if self.context.prover_version else '',
@@ -592,43 +605,32 @@ 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])
-
-            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 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)
 
-                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_summaries:
+                    rust_jar_settings.append('-solanaSummaries')
+                    rust_jar_settings.append(paths_in_source_dir(self.context.solana_summaries))
+
+                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
+
+        elif Attrs.is_sui_app():
+            sui_jar_settings = ['-movePath', Path(self.context.move_path).name]
+            auth_data["jarSettings"] = sui_jar_settings + jar_settings
+
+        elif Attrs.is_concord_app():
+            auth_data["jarSettings"] = jar_settings + ["-equivalenceCheck", "true"]
         else:
             auth_data["jarSettings"] = jar_settings
 
@@ -646,6 +648,22 @@ 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
+        elif Attrs.is_sui_app():
+            auth_data["ecosystem"] = EcoEnum.SUI.name
+        else:
+            auth_data["ecosystem"] = EcoEnum.EVM.name
+
+        if Attrs.is_ranger_app():
+            auth_data["product"] = ProductEnum.RANGER.name
+        elif Attrs.is_concord_app():
+            auth_data["product"] = ProductEnum.CONCORD.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
 
@@ -671,18 +689,21 @@ class CloudVerification:
             auth_data["mutationTestId"] = self.context.mutation_test_id
         return auth_data
 
+    def get_group_id_url(self) -> str:
+        return f"{self.get_domain()}/?groupIds={self.context.group_id}"
+
     def print_group_id_url(self) -> None:
-        group_id_url = f"{self.get_domain()}/?groupIds={self.context.group_id}"
+        group_id_url = self.get_group_id_url()
         print(f"See all jobs generated from splitting the rules at {group_id_url}", flush=True)
 
     def print_output_links(self) -> None:
         print(f"Manage your jobs at {self.get_domain()}")
-        print(f"Follow your job and see verification results at {self.reportUrl}", flush=True)
+        print(f"Follow your job and see verification results at {self.url_print_format()}", flush=True)
 
     def print_verification_summary(self) -> None:
         report_exists = self.check_file_exists(params={"filename": "index.html", "certoraKey": self.context.key})
         if report_exists:
-            print(f"Job is completed! View the results at {self.reportUrl}")
+            print(f"Job is completed! View the results at {self.url_print_format()}")
         print("Finished verification request", flush=True)
 
     def __send_verification_request(self, cl_args: str) -> bool:
@@ -747,69 +768,34 @@ 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_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)
-
-                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):
                     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():
-                # We zip the ELF files and the two configuration files
-                jar_args = Ctx.collect_jar_args(self.context)
-
-                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:
-                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))
+        elif Attrs.is_sui_app():
+            files_list = [Util.get_certora_metadata_file(),
+                          Util.get_configuration_layout_data_file(),
+                          Util.get_build_dir() / Path(self.context.move_path).name]
+
+            if Util.get_certora_sources_dir().exists():
+                files_list.append(Util.get_certora_sources_dir())
+
+            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
@@ -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
 
@@ -884,7 +873,7 @@ class CloudVerification:
             self.runName, self.reportUrl, self.msg, self.get_domain(), str(self.userId), self.anonymousKey)
 
         # Generate a json file for the VS Code extension with the relevant url
-        self.vscode_extension_info_writer.add_field("verification_report_url", self.reportUrl)
+        self.vscode_extension_info_writer.add_field("verification_report_url", self.url_print_format())
         self.vscode_extension_info_writer.write_file()
 
         if not wait_for_results or wait_for_results == str(Vf.WaitForResultOptions.NONE):
@@ -964,6 +953,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
@@ -1171,6 +1162,12 @@ class CloudVerification:
         Util.remove_file(self.ZipFilePath)
         Util.remove_file(self.logZipFilePath)
 
+    def url_print_format(self) -> str:
+        if self.reportUrl and self.context.url_visibility == str(Vf.UrlVisibilityOptions.PRIVATE):
+            return self.privatize_url()
+        else:
+            return self.reportUrl
+
     @lru_cache(maxsize=1, typed=False)
     def get_domain(self) -> str:
         """
@@ -1186,3 +1183,7 @@ class CloudVerification:
             domain = Util.SupportedServers.PRODUCTION.value
 
         return domain
+
+    @lru_cache(maxsize=1)
+    def privatize_url(self) -> str:
+        return self.reportUrl.split('?anonymousKey=')[0]