apollo_integration_tests: fix non-interpolating .expect() messages and log typos (#14069)

The original motivating bug lives in apollo_integration_tests:

    // crates/apollo_integration_tests/src/integration_test_manager.rs
    .expect("Service {service:?} does not exist in the running executables map.");
    .expect("Node {node_idx} does not exist in idle or running nodes.");

`.expect()` is an ordinary method on Option/Result that takes a `&str` and
prints it verbatim on panic — it does not invoke `format_args!`. So named
arguments inside the braces never get substituted:

    Before: thread '...' panicked at 'Service {service:?} does not exist in the running executables map.'
    After:  thread '...' panicked at 'Service Batcher does not exist in the running executables map.'

The panic still fires at the right moment for the right reason; only the
diagnostic value is lost, which defeats the whole point of embedding the
variable. The fix is to wrap the call as `.unwrap_or_else(|| panic!(...))`
(or `|err| panic!("...: {err}")` on a Result), since `panic!` IS a format
macro and the placeholders interpolate normally.

A workspace grep revealed the same anti-pattern in nine more places, plus a
small batch of unrelated typos in user-facing log/panic/assert strings.
Bundling them all here because the common audit "are all log strings in the
sequencer correct?" is what surfaced them.

.expect() placeholder fixes (panic message would have been useless before):
  - apollo_storage/src/header.rs                                 ({block_number})
  - apollo_consensus_manager/src/consensus_manager.rs            ({height})
  - apollo_consensus/src/manager.rs                              (was {self.height} -- field access also invalid in fmt; corrected to local {height})
  - apollo_storage/src/serialization/serializers_test.rs         (7 sites; one referenced an out-of-scope {casm_file}, corrected to {bin_file_name})
  - starknet_os/.../state_diff_encryption/utils.rs               ({public_key}, {sn_public_key})
  - apollo_integration_tests/src/integration_test_manager.rs     ({service:?}, {node_idx})
  - apollo_batcher/src/batcher.rs                                ({new_latest_height})

Plain typo fixes in log/panic/assert messages:
  - apollo_integration_tests/src/integration_test_manager.rs     "succesfully" -> "successfully" (info!)
  - blockifier/src/execution/entry_point.rs                      "to to usize" -> "to usize" (log::warn!, duplicate word)
  - apollo_monitoring_endpoint/src/monitoring_endpoint.rs        "MointoringEndpoint" -> "MonitoringEndpoint" (panic!)
  - starknet_patricia/.../filled_tree/tree.rs                    "a unmodified" -> "an unmodified" (panic!)
  - apollo_integration_tests/src/flow_test_setup.rs              "a init message" -> "an init message" (panic!)
  - apollo_infra_utils/src/path_test.rs                          "an non-existent" -> "a non-existent" (assert!)

No behavior change beyond what panic messages display; cargo check --tests
passes on all touched crates.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ron-starkware

crates/apollo_batcher/src/batcher.rs

@@ -1428,7 +1428,9 @@ impl Batcher {
                     .storage_reader
                     .global_root(new_latest_height)
                     .expect("Failed to get global root from storage.")
-                    .expect("Global root is not set for height {new_latest_height}.");
+                    .unwrap_or_else(|| {
+                        panic!("Global root is not set for height {new_latest_height}.")
+                    });
                 assert_eq!(
                     global_root, stored_global_root,
                     "The given global root does not match the stored global root for height \

crates/apollo_consensus/src/manager.rs

@@ -1048,7 +1048,9 @@ impl<ContextT: ConsensusContext> MultiHeightManager<ContextT> {
                     .lock()
                     .await
                     .set_prev_voted_height(height)
-                    .expect("Failed to write voted height {self.height} to storage");
+                    .unwrap_or_else(|err| {
+                        panic!("Failed to write voted height {height} to storage: {err:?}")
+                    });
                 context.broadcast(vote.clone()).await?;
                 // Schedule a rebroadcast after the appropriate timeout.
                 let duration = match vote.vote_type {

crates/apollo_consensus_manager/src/consensus_manager.rs

@@ -350,10 +350,9 @@ impl ConsensusManager {
 
         // This function will panic if the revert fails.
         let revert_blocks_fn = move |height| async move {
-            self.batcher_client
-                .revert_block(RevertBlockInput { height })
-                .await
-                .expect("Failed to revert block at height {height} in the batcher");
+            self.batcher_client.revert_block(RevertBlockInput { height }).await.unwrap_or_else(
+                |err| panic!("Failed to revert block at height {height} in the batcher: {err:?}"),
+            );
         };
 
         const BATCHER_REVERT_COMPONENT_DATA: RevertComponentData = RevertComponentData {

crates/apollo_infra_utils/src/path_test.rs

@@ -7,7 +7,7 @@ fn resolve_project_relative_path_on_non_existent_path() {
     assert!(!expected_path.exists());
     let result = resolve_project_relative_path(relative_path);
 
-    assert!(result.is_err(), "Expected an non-existent path error, got {result:?}");
+    assert!(result.is_err(), "Expected a non-existent path error, got {result:?}");
 }
 
 #[test]

crates/apollo_integration_tests/src/flow_test_setup.rs

@@ -482,7 +482,7 @@ impl TxCollector {
             "Expected the first message in the stream to have id 0, got {incoming_message_id}"
         );
         let StreamMessageBody::Content(ProposalPart::Init(incoming_init)) = init_message else {
-            panic!("Expected a init message. Got: {init_message:?}")
+            panic!("Expected an init message. Got: {init_message:?}")
         };
 
         self.accumulated_txs.lock().await.start_round(incoming_init.height, incoming_init.round);

crates/apollo_integration_tests/src/integration_test_manager.rs

@@ -363,10 +363,9 @@ impl RunningNode {
     }
 
     pub fn shutdown_service(&mut self, service: NodeService) {
-        let handle = self
-            .executable_handles
-            .remove(&service)
-            .expect("Service {service:?} does not exist in the running executables map.");
+        let handle = self.executable_handles.remove(&service).unwrap_or_else(|| {
+            panic!("Service {service:?} does not exist in the running executables map.")
+        });
         assert!(!handle.is_finished(), "Handle should still be running.");
         handle.abort();
     }
@@ -448,7 +447,7 @@ impl IntegrationTestManager {
             .idle_nodes
             .get(&node_idx)
             .or_else(|| self.running_nodes.get(&node_idx).map(|node| &node.node_setup))
-            .expect("Node {node_idx} does not exist in idle or running nodes.");
+            .unwrap_or_else(|| panic!("Node {node_idx} does not exist in idle or running nodes."));
         node_setup.node_type
     }
 
@@ -631,7 +630,7 @@ impl IntegrationTestManager {
             .expect("Running Nodes should be reverted.");
 
         info!(
-            "All running nodes have been reverted succesfully to block number \
+            "All running nodes have been reverted successfully to block number \
              {expected_block_number}."
         );
     }

crates/apollo_monitoring_endpoint/src/monitoring_endpoint.rs

@@ -143,7 +143,7 @@ pub fn create_monitoring_endpoint(
 impl ComponentStarter for MonitoringEndpoint {
     async fn start(&mut self) {
         info!("Starting component {}.", short_type_name::<Self>());
-        self.run().await.unwrap_or_else(|e| panic!("Failed to start MointoringEndpoint: {e:?}"));
+        self.run().await.unwrap_or_else(|e| panic!("Failed to start MonitoringEndpoint: {e:?}"));
     }
 }
 

crates/apollo_storage/src/header.rs

@@ -390,7 +390,7 @@ impl HeaderStorageWriter for StorageTxn<'_, RW> {
 
         let reverted_header = headers_table
             .get(&self.txn, &block_number)?
-            .expect("Missing header for block {block_number}.");
+            .unwrap_or_else(|| panic!("Missing header for block {block_number}."));
         markers_table.upsert(&self.txn, &MarkerKind::Header, &block_number)?;
         headers_table.delete(&self.txn, &block_number)?;
         block_hash_to_number_table.delete(&self.txn, &reverted_header.block_hash)?;

crates/apollo_storage/src/serialization/serializers_test.rs

@@ -155,14 +155,15 @@ fn casm_serialization_regression() {
         let mut serialized: Vec<u8> = Vec::new();
         json_casm
             .serialize_into(&mut serialized)
-            .expect("Failed to serialize casm file: {json_file_name}");
+            .unwrap_or_else(|_| panic!("Failed to serialize casm file: {json_file_name}"));
         let bin_path = path_in_resources(Path::new("casm").join(bin_file_name));
-        let mut bin_file = File::open(bin_path)
-            .expect("Failed to open bin file: {bin_file_name}\n{FIX_SUGGESTION}");
+        let mut bin_file = File::open(bin_path).unwrap_or_else(|_| {
+            panic!("Failed to open bin file: {bin_file_name}\n{FIX_SUGGESTION}")
+        });
         let mut regression_casm_bytes = Vec::new();
-        bin_file
-            .read_to_end(&mut regression_casm_bytes)
-            .expect("Failed to read bin file: {bin_file_name}\n{FIX_SUGGESTION}");
+        bin_file.read_to_end(&mut regression_casm_bytes).unwrap_or_else(|_| {
+            panic!("Failed to read bin file: {bin_file_name}\n{FIX_SUGGESTION}")
+        });
         assert_eq!(
             regression_casm_bytes, serialized,
             "Serializing the casm gave a result different from the hardcoded \
@@ -179,16 +180,17 @@ fn casm_deserialization_regression() {
     }
 
     for (json_file_name, bin_file_name) in CASM_SERIALIZATION_REGRESSION_FILES {
-        let mut regression_casm_file =
-            File::open(path_in_resources(Path::new("casm").join(bin_file_name)))
-                .expect("Failed to open bin file: {bin_file_name}\n{FIX_SUGGESTION}");
+        let mut regression_casm_file = File::open(path_in_resources(
+            Path::new("casm").join(bin_file_name),
+        ))
+        .unwrap_or_else(|_| panic!("Failed to open bin file: {bin_file_name}\n{FIX_SUGGESTION}"));
         let mut regression_casm_bytes = Vec::new();
-        regression_casm_file
-            .read_to_end(&mut regression_casm_bytes)
-            .expect("Failed to read bin file: {bin_file_name}\n{FIX_SUGGESTION}");
+        regression_casm_file.read_to_end(&mut regression_casm_bytes).unwrap_or_else(|_| {
+            panic!("Failed to read bin file: {bin_file_name}\n{FIX_SUGGESTION}")
+        });
         let regression_casm =
             CasmContractClass::deserialize_from(&mut regression_casm_bytes.as_slice())
-                .expect("Failed to deserialize casm file: {casm_file}.");
+                .unwrap_or_else(|| panic!("Failed to deserialize casm file: {bin_file_name}."));
         let json_path = format!("casm/{json_file_name}");
         let json_casm: CasmContractClass = read_json_file(&json_path);
         assert_eq!(
@@ -208,7 +210,7 @@ fn fix_casm_regression_files() {
         let casm_bytes = serialized.into_boxed_slice();
         let mut hardcoded_file =
             File::create(path_in_resources(Path::new("casm").join(bin_file_name)))
-                .expect("Failed to create bin file {bin_file_name}\n");
+                .unwrap_or_else(|_| panic!("Failed to create bin file {bin_file_name}\n"));
         hardcoded_file.write_all(&casm_bytes).unwrap();
     }
 }

crates/blockifier/src/execution/entry_point.rs

@@ -394,7 +394,7 @@ impl EntryPointExecutionContext {
         }
         .try_into()
         .unwrap_or_else(|error| {
-            log::warn!("Failed to convert global step limit to to usize: {error}.");
+            log::warn!("Failed to convert global step limit to usize: {error}.");
             usize::MAX
         });