[Fix] Account for dynamic dispatch in CLI stats. (#29258)

Author: d0cd

crates/leo/src/cli/commands/common/output.rs

@@ -30,14 +30,17 @@ pub(crate) fn microcredits_to_credits(microcredits: u64) -> f64 {
 pub struct FunctionCostStats {
     pub name: String,
     pub finalize_cost: u64,
-    /// The cost of proving the execution transition (execution_cost - finalize_cost).
+    /// The storage cost of the execution transition (execution_cost - finalize_cost).
     /// `None` when authorization sampling fails (e.g. functions requiring specific record types).
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub proof_cost: Option<u64>,
+    pub storage_cost: Option<u64>,
     /// The total execution cost (finalize + proof).
     /// `None` when authorization sampling fails (e.g. functions requiring specific record types).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub execution_cost: Option<u64>,
+    /// Whether this function uses dynamic calls, making the finalize cost a lower bound.
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub has_dynamic_calls: bool,
 }
 
 /// Statistics for a deployed program.
@@ -123,15 +126,46 @@ impl fmt::Display for DeploymentStats {
 
         for fc in &self.function_costs {
             writeln!(f, "{}", format!("  Function '{}'", fc.name).bold())?;
+            let bound = if fc.has_dynamic_calls { " (lower bound)" } else { "" };
             if let Some(execution_cost) = fc.execution_cost {
-                writeln!(f, "    {:24}{:.6}", "Total Execution Cost:".cyan(), microcredits_to_credits(execution_cost))?;
-                writeln!(f, "    {:24}{:.6}", "|- Finalize Cost:".cyan(), microcredits_to_credits(fc.finalize_cost))?;
-                if let Some(proof_cost) = fc.proof_cost {
-                    writeln!(f, "    {:24}{:.6}", "|- Proof Cost:".cyan(), microcredits_to_credits(proof_cost))?;
+                writeln!(
+                    f,
+                    "    {:24}{:.6}{}",
+                    "Total Execution Cost:".cyan(),
+                    microcredits_to_credits(execution_cost),
+                    bound.dimmed()
+                )?;
+                if let Some(storage_cost) = fc.storage_cost {
+                    writeln!(
+                        f,
+                        "    {:24}{:.6}{}",
+                        "|- Storage Cost:".cyan(),
+                        microcredits_to_credits(storage_cost),
+                        bound.dimmed()
+                    )?;
                 }
+                writeln!(
+                    f,
+                    "    {:24}{:.6}{}",
+                    "|- Finalize Cost:".cyan(),
+                    microcredits_to_credits(fc.finalize_cost),
+                    bound.dimmed()
+                )?;
             } else {
-                writeln!(f, "    {:24}{}", "Total Execution Cost:".cyan(), "Undetermined".dimmed())?;
-                writeln!(f, "    {:24}{:.6}", "|- Finalize Cost:".cyan(), microcredits_to_credits(fc.finalize_cost))?;
+                writeln!(
+                    f,
+                    "    {:24}{:.6} (lower bound)",
+                    "Total Execution Cost:".cyan(),
+                    microcredits_to_credits(fc.finalize_cost),
+                )?;
+                writeln!(f, "    {:24}{}", "|- Storage Cost:".cyan(), "N/A (dynamic call)".dimmed())?;
+                writeln!(
+                    f,
+                    "    {:24}{:.6}{}",
+                    "|- Finalize Cost:".cyan(),
+                    microcredits_to_credits(fc.finalize_cost),
+                    bound.dimmed()
+                )?;
             }
         }
         Ok(())

crates/leo/src/cli/commands/deploy.rs

@@ -827,16 +827,9 @@ pub(crate) fn calculate_function_costs<N: Network, R: Rng + CryptoRng>(
     for (function_name, _) in deployment.function_verifying_keys() {
         let name = function_name.to_string();
 
-        // Compute the finalize cost based on the consensus version.
-        let finalize_cost = if consensus_version >= ConsensusVersion::V10 {
-            minimum_cost_in_microcredits_v3(&stack, function_name)?
-        } else if consensus_version >= ConsensusVersion::V2 {
-            minimum_cost_in_microcredits_v2(&stack, function_name)?
-        } else {
-            minimum_cost_in_microcredits_v1(&stack, function_name)?
-        };
-
         // Sample inputs and attempt authorization to estimate execution cost (best-effort).
+        // When authorization succeeds, use the breakdown directly from snarkVM.
+        // When it fails, fall back to the static finalize cost.
         let input_types = deployment.program().get_function(function_name)?.input_types();
         let inputs = input_types
             .into_iter()
@@ -846,20 +839,32 @@ pub(crate) fn calculate_function_costs<N: Network, R: Rng + CryptoRng>(
                     .map_err(|e| CliError::custom(format!("Failed to sample value: {e}")).into())
             })
             .collect::<Result<Vec<_>>>()?;
-        let execution_cost =
+        let (finalize_cost, storage_cost, execution_cost) =
             match vm.authorize(&sample_key, deployment.program().id(), function_name, inputs.iter(), rng) {
                 Err(e) => {
                     tracing::debug!("Could not estimate execution cost for '{name}': {e}");
-                    None
+                    // Fall back to static finalize cost analysis.
+                    let static_finalize_cost = if consensus_version >= ConsensusVersion::V10 {
+                        minimum_cost_in_microcredits_v3(&stack, function_name)?
+                    } else if consensus_version >= ConsensusVersion::V2 {
+                        minimum_cost_in_microcredits_v2(&stack, function_name)?
+                    } else {
+                        minimum_cost_in_microcredits_v1(&stack, function_name)?
+                    };
+                    (static_finalize_cost, None, None)
                 }
                 Ok(authorization) => {
-                    Some(execution_cost_for_authorization(&vm.process().read(), &authorization, consensus_version)?.0)
+                    let (total, (storage, finalize)) =
+                        execution_cost_for_authorization(&vm.process().read(), &authorization, consensus_version)?;
+                    (finalize, Some(storage), Some(total))
                 }
             };
 
-        let proof_cost = execution_cost.map(|ec| ec.saturating_sub(finalize_cost));
+        // Check if this function (or any function it calls) uses dynamic dispatch.
+        // Dynamic calls make costs a lower bound since the target is resolved at runtime.
+        let has_dynamic_calls = stack.contains_dynamic_call(function_name).unwrap_or(false);
 
-        function_costs.push(FunctionCostStats { name, finalize_cost, proof_cost, execution_cost });
+        function_costs.push(FunctionCostStats { name, finalize_cost, storage_cost, execution_cost, has_dynamic_calls });
     }
 
     Ok(function_costs)

crates/leo/src/cli/commands/synthesize.rs

@@ -230,19 +230,27 @@ fn handle_synthesize<A: Aleo>(
         Ok(hex)
     };
 
+    // Collect record names for translation key synthesis.
+    let record_names: Vec<_> = stack.program().records().keys().cloned().collect();
+
     println!("\n🌱 Synthesizing the following keys in {program_id}:");
     for id in &function_ids {
-        println!("    - {id}");
+        println!("    - {id} (function)");
+    }
+    for name in &record_names {
+        println!("    - {name} (record translation)");
     }
 
     let mut synthesized_functions = Vec::new();
 
-    for function_id in function_ids {
-        stack.synthesize_key::<A, _>(function_id, rng)?;
-        let proving_key = stack.get_proving_key(function_id)?;
-        let verifying_key = stack.get_verifying_key(function_id)?;
+    // Helper: process a synthesized key (function or translation), print circuit info,
+    // record metadata, and optionally save keys to disk.
+    let mut process_key = |name: &str, label: &str| -> Result<()> {
+        let name_id = snarkvm::prelude::Identifier::<A::Network>::from_str(name)?;
+        let proving_key = stack.get_proving_key(&name_id)?;
+        let verifying_key = stack.get_verifying_key(&name_id)?;
 
-        println!("\n🔑 Synthesized keys for {program_id}/{function_id} (edition {edition})");
+        println!("\n🔑 Synthesized {label} for {program_id}/{name} (edition {edition})");
         println!("ℹ️ Circuit Information:");
         println!("    - Public Inputs: {}", verifying_key.circuit_info.num_public_inputs);
         println!("    - Variables: {}", verifying_key.circuit_info.num_public_and_private_variables);
@@ -252,13 +260,11 @@ fn handle_synthesize<A: Aleo>(
         println!("    - Non-Zero Entries in C: {}", verifying_key.circuit_info.num_non_zero_c);
         println!("    - Circuit ID: {}", verifying_key.id);
 
-        // Get the checksums of the keys.
         let prover_bytes = proving_key.to_bytes_le()?;
         let verifier_bytes = verifying_key.to_bytes_le()?;
         let prover_checksum = hash(&prover_bytes)?;
         let verifier_checksum = hash(&verifier_bytes)?;
 
-        // Construct the metadata.
         let metadata = Metadata {
             prover_checksum,
             prover_size: prover_bytes.len(),
@@ -279,44 +285,44 @@ fn handle_synthesize<A: Aleo>(
         };
 
         synthesized_functions.push(SynthesizedFunction {
-            name: function_id.to_string(),
+            name: name.to_string(),
             circuit_info,
             metadata: metadata.clone(),
         });
 
-        // A helper to write to a file.
-        let write_to_file = |path: PathBuf, data: &[u8]| -> Result<()> {
-            std::fs::write(path, data).map_err(|e| CliError::custom(format!("Failed to write to file: {e}")))?;
-            Ok(())
-        };
-
-        // If the `save` option is set, save the proving and verifying keys to a file in the specified directory.
-        // The file format is `program_id.function_id.edition_or_local.type.timestamp`.
-        // The directory is created if it doesn't exist.
         if let Some(path) = &command.action.save {
-            // Create the directory if it doesn't exist.
             std::fs::create_dir_all(path).map_err(|e| CliError::custom(format!("Failed to create directory: {e}")))?;
-            // Get the current timestamp.
             let timestamp = chrono::Utc::now().timestamp();
-            // The edition.
-            let edition = if command.local { "local".to_string() } else { edition.to_string() };
-            // The prefix for the file names.
-            let prefix = format!("{network}.{program_id}.{function_id}.{edition}");
-            // Get the file paths.
+            let edition_str = if command.local { "local".to_string() } else { edition.to_string() };
+            let prefix = format!("{network}.{program_id}.{name}.{edition_str}");
             let prover_file_path = PathBuf::from(path).join(format!("{prefix}.prover.{timestamp}"));
             let verifier_file_path = PathBuf::from(path).join(format!("{prefix}.verifier.{timestamp}"));
-            let metadata_file_path = PathBuf::from(path)
-                .join(format!("{network}.{program_id}.{function_id}.{edition}.metadata.{timestamp}"));
-            // Print the save location.
+            let metadata_file_path = PathBuf::from(path).join(format!("{prefix}.metadata.{timestamp}"));
             println!(
-                "💾 Saving proving key, verifying key, and metadata to: {}/{network}.{program_id}.{function_id}.{edition}.prover|verifier|metadata.{timestamp}",
+                "💾 Saving {label} to: {}/{prefix}.prover|verifier|metadata.{timestamp}",
                 metadata_file_path.parent().unwrap().display()
             );
-            // Save the keys.
-            write_to_file(prover_file_path, &prover_bytes)?;
-            write_to_file(verifier_file_path, &verifier_bytes)?;
-            write_to_file(metadata_file_path, metadata_pretty.as_bytes())?;
+            std::fs::write(&prover_file_path, &prover_bytes)
+                .map_err(|e| CliError::custom(format!("Failed to write to file: {e}")))?;
+            std::fs::write(&verifier_file_path, &verifier_bytes)
+                .map_err(|e| CliError::custom(format!("Failed to write to file: {e}")))?;
+            std::fs::write(&metadata_file_path, metadata_pretty.as_bytes())
+                .map_err(|e| CliError::custom(format!("Failed to write to file: {e}")))?;
         }
+
+        Ok(())
+    };
+
+    // Synthesize function keys.
+    for function_id in function_ids {
+        stack.synthesize_key::<A, _>(function_id, rng)?;
+        process_key(&function_id.to_string(), "keys")?;
+    }
+
+    // Synthesize record translation keys.
+    for record_name in &record_names {
+        stack.synthesize_translation_key::<A, _>(record_name, rng)?;
+        process_key(&record_name.to_string(), "translation key")?;
     }
 
     Ok(SynthesizeOutput { program: program_id.to_string(), functions: synthesized_functions })

tests/expectations/cli/broadcast_error/STDOUT

@@ -58,8 +58,8 @@ Once it is deployed, it CANNOT be changed.
   Total Fee:            1.946118
   Function 'main'
     Total Execution Cost:   0.001326
+    |- Storage Cost:        0.001326
     |- Finalize Cost:       0.000000
-    |- Proof Cost:          0.001326
 ──────────────────────────────────────────────
 
 📡 Broadcasting deployment for broadcast_error.aleo...
@@ -138,8 +138,8 @@ Once it is deployed, it CANNOT be changed.
   Total Fee:            1.946118
   Function 'main'
     Total Execution Cost:   0.001326
+    |- Storage Cost:        0.001326
     |- Finalize Cost:       0.000000
-    |- Proof Cost:          0.001326
 ──────────────────────────────────────────────
 
 📡 Broadcasting deployment for broadcast_error.aleo...

tests/expectations/cli/network_dependency/STDOUT

@@ -59,8 +59,8 @@ Once it is deployed, it CANNOT be changed.
   Total Fee:            1.897896
   Function 'main'
     Total Execution Cost:   0.001283
+    |- Storage Cost:        0.001283
     |- Finalize Cost:       0.000000
-    |- Proof Cost:          0.001283
 ──────────────────────────────────────────────
 
 📡 Broadcasting deployment for test_program1.aleo...
@@ -141,8 +141,8 @@ Once it is deployed, it CANNOT be changed.
   Total Fee:            1.954701
   Function 'main'
     Total Execution Cost:   0.001994
+    |- Storage Cost:        0.001994
     |- Finalize Cost:       0.000000
-    |- Proof Cost:          0.001994
 ──────────────────────────────────────────────
 
 📡 Broadcasting deployment for test_program2.aleo...

tests/expectations/cli/test_deploy/STDOUT

@@ -1,9 +1,9 @@
 
        Leo 🔨 Compiling 'some_sample_leo_program.aleo'
-       Leo     2 statements before dead code elimination.
-       Leo     2 statements after dead code elimination.
-       Leo     The program checksum is: '[95u8, 99u8, 136u8, 243u8, 82u8, 169u8, 200u8, 72u8, 133u8, 227u8, 122u8, 161u8, 195u8, 178u8, 69u8, 37u8, 167u8, 114u8, 104u8, 192u8, 161u8, 175u8, 195u8, 180u8, 120u8, 4u8, 192u8, 16u8, 86u8, 199u8, 76u8, 235u8]'.
-       Leo     Program size: 0.20 KB / 500.00 KB
+       Leo     8 statements before dead code elimination.
+       Leo     8 statements after dead code elimination.
+       Leo     The program checksum is: '[109u8, 115u8, 37u8, 36u8, 104u8, 211u8, 71u8, 47u8, 167u8, 121u8, 76u8, 58u8, 12u8, 161u8, 114u8, 2u8, 167u8, 69u8, 23u8, 209u8, 243u8, 251u8, 90u8, 233u8, 85u8, 135u8, 145u8, 25u8, 18u8, 86u8, 72u8, 144u8]'.
+       Leo     Program size: 0.68 KB / 500.00 KB
        Leo ✅ Compiled 'some_sample_leo_program.aleo' into Aleo instructions.
        Leo ✅ Generated ABI at 'build/abi.json'.
 
@@ -43,23 +43,31 @@ Once it is deployed, it CANNOT be changed.
 
 📊 Deployment Summary for some_sample_leo_program.aleo
 ──────────────────────────────────────────────
-  Program Size:         0.20 KB / 500.00 KB
-  Total Variables:      17,516
-  Total Constraints:    12,927
+  Program Size:         0.68 KB / 500.00 KB
+  Total Variables:      99,771
+  Total Constraints:    76,101
   Max Variables:        XXXXXX
   Max Constraints:      XXXXXX
 
 💰 Cost Breakdown (credits)
-  Transaction Storage:  0.892000
-  Program Synthesis:    0.030443
+  Transaction Storage:  3.270000
+  Program Synthesis:    0.175872
   Namespace:            1.000000
   Constructor:          0.002000
   Priority Fee:         0.000000
-  Total Fee:            1.924443
+  Total Fee:            4.447872
   Function 'main'
     Total Execution Cost:   0.001334
+    |- Storage Cost:        0.001334
     |- Finalize Cost:       0.000000
-    |- Proof Cost:          0.001334
+  Function 'mint'
+    Total Execution Cost:   0.001536
+    |- Storage Cost:        0.001536
+    |- Finalize Cost:       0.000000
+  Function 'dynamic_transfer'
+    Total Execution Cost:   0.000000 (lower bound)
+    |- Storage Cost:        N/A (dynamic call)
+    |- Finalize Cost:       0.000000 (lower bound)
 ──────────────────────────────────────────────
 
 📡 Broadcasting deployment for some_sample_leo_program.aleo...