Merge pull request #2874 from ProvableHQ/improved_varuna_logging_2

vicsn · web-flow · commit 98998c25902a · 2025-08-19T16:24:11.000+02:00
Improved varuna logging
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -138,10 +138,17 @@ package = [
   "dep:ureq",
   "dep:dotenvy"
 ]
-aleo-cli = [ "snarkvm-synthesizer/aleo-cli" ]
 async = [ "snarkvm-ledger/async", "snarkvm-synthesizer/async" ]
 cuda = [ "snarkvm-algorithms/cuda" ]
-dev-print = [ "snarkvm-utilities/dev-print" ]
+dev-print = [ 
+  "snarkvm-utilities/dev-print",
+  "snarkvm-algorithms/dev-print",
+  "snarkvm-circuit/dev-print",
+  "snarkvm-curves/dev-print",
+  "snarkvm-fields/dev-print",
+  "snarkvm-parameters/dev-print",
+  "snarkvm-synthesizer/dev-print",
+]
 save_r1cs_hashes = [ "snarkvm-circuit/save_r1cs_hashes" ]
 history = [ "snarkvm-synthesizer/history" ]
 parameters_no_std_out = [ "snarkvm-parameters/no_std_out" ]
diff --git a/algorithms/src/errors.rs b/algorithms/src/errors.rs
@@ -44,9 +44,6 @@ pub enum SNARKError {
 
     #[error("Public input size was different from the circuit")]
     PublicInputSizeMismatch,
-
-    #[error("Circuit not found")]
-    CircuitNotFound,
 }
 
 impl From<AHPError> for SNARKError {
diff --git a/algorithms/src/snark/varuna/varuna.rs b/algorithms/src/snark/varuna/varuna.rs
@@ -46,7 +46,7 @@ use crate::{
 use rand::RngCore;
 use snarkvm_curves::PairingEngine;
 use snarkvm_fields::{One, PrimeField, ToConstraintField, Zero};
-use snarkvm_utilities::{ToBytes, to_bytes_le};
+use snarkvm_utilities::{ToBytes, dev_eprintln, dev_println, to_bytes_le};
 
 use anyhow::{Result, anyhow, bail, ensure};
 use core::marker::PhantomData;
@@ -297,10 +297,10 @@ where
         let circuit_id = &verifying_key.id;
         let state = AHPForR1CS::<E::Fr, SM>::index_helper(circuit)?;
         if state.index_info != verifying_key.circuit_info {
-            bail!(SNARKError::CircuitNotFound);
+            bail!("Circuit info mismatch, expected {:?}, got {:?}", verifying_key.circuit_info, state.index_info);
         }
         if state.id != *circuit_id {
-            bail!(SNARKError::CircuitNotFound);
+            bail!("Circuit ID mismatch, expected {:?}, got {:?}.", circuit_id, state.id);
         }
 
         // Make sure certificate is not hiding
@@ -376,10 +376,10 @@ where
         let num_unique_circuits = keys_to_constraints.len();
         let mut circuit_ids = Vec::with_capacity(num_unique_circuits);
         for pk in keys_to_constraints.keys() {
-            let batch_size = prover_state.batch_size(&pk.circuit).ok_or(SNARKError::CircuitNotFound)?;
-            let public_input = prover_state.public_inputs(&pk.circuit).ok_or(SNARKError::CircuitNotFound)?;
+            let batch_size = prover_state.batch_size(&pk.circuit).ok_or(anyhow!("Batch size not found."))?;
+            let public_input = prover_state.public_inputs(&pk.circuit).ok_or(anyhow!("Public input not found."))?;
             let padded_public_input =
-                prover_state.padded_public_inputs(&pk.circuit).ok_or(SNARKError::CircuitNotFound)?;
+                prover_state.padded_public_inputs(&pk.circuit).ok_or(anyhow!("Padded public input not found."))?;
             let circuit_id = pk.circuit.id;
             batch_sizes.insert(circuit_id, batch_size);
             circuit_infos.insert(circuit_id, &pk.circuit_verifying_key.circuit_info);
@@ -766,9 +766,7 @@ where
                         let mut new_input = Vec::with_capacity(input_len);
                         new_input.extend_from_slice(input);
                         new_input.resize(input_len, E::Fr::zero());
-                        if cfg!(debug_assertions) {
-                            println!("Number of padded public variables: {}", new_input.len());
-                        }
+                        dev_println!("Number of padded public variables: {}", new_input.len());
                         let unformatted = prover::ConstraintSystem::unformat_public_input(&new_input);
                         (new_input, unformatted)
                     })
@@ -796,7 +794,7 @@ where
             !proof.pc_proof.is_hiding() & comms.mask_poly.is_none()
         };
         if !proof_has_correct_zk_mode {
-            eprintln!(
+            dev_eprintln!(
                 "Found `mask_poly` in the first round when not expected, or proof has incorrect hiding mode ({})",
                 proof.pc_proof.is_hiding()
             );
@@ -1016,8 +1014,7 @@ where
         end_timer!(pc_time);
 
         if !evaluations_are_correct {
-            #[cfg(debug_assertions)]
-            eprintln!("SonicKZG10::Check failed using final challenge: {:?}", verifier_state.gamma);
+            dev_eprintln!("SonicKZG10::Check failed using final challenge: {:?}", verifier_state.gamma);
         }
 
         end_timer!(verifier_time, || format!(
diff --git a/circuit/Cargo.toml b/circuit/Cargo.toml
@@ -25,6 +25,7 @@ edition = "2024"
 
 [features]
 save_r1cs_hashes = [ "snarkvm-circuit-environment/save_r1cs_hashes" ]
+dev-print = ["snarkvm-circuit-environment/dev-print"]
 
 [dependencies.snarkvm-circuit-account]
 workspace = true
diff --git a/synthesizer/Cargo.toml b/synthesizer/Cargo.toml
@@ -31,7 +31,6 @@ locktick = [
   "snarkvm-ledger-store/locktick",
   "snarkvm-synthesizer-process/locktick"
 ]
-aleo-cli = [ ]
 async = [ "snarkvm-ledger-query/async", "snarkvm-synthesizer-process/async" ]
 cuda = [ "snarkvm-algorithms/cuda" ]
 history = [ "serde" ]
diff --git a/synthesizer/process/Cargo.toml b/synthesizer/process/Cargo.toml
@@ -25,7 +25,6 @@ edition = "2024"
 
 [features]
 default = [ "indexmap/rayon", "rayon" ]
-aleo-cli = [ ]
 async = [ "snarkvm-ledger-query/async" ]
 locktick = [ "dep:locktick", "snarkvm-ledger-store/locktick" ]
 rocks = [ "snarkvm-ledger-store/rocks" ]
diff --git a/synthesizer/process/src/evaluate.rs b/synthesizer/process/src/evaluate.rs
@@ -24,8 +24,7 @@ impl<N: Network> Process<N> {
         // Retrieve the top-level request (without popping it).
         let request = authorization.peek_next()?;
 
-        #[cfg(feature = "aleo-cli")]
-        println!("{}", format!(" • Evaluating '{}/{}'...", request.program_id(), request.function_name()).dimmed());
+        dev_println!("{}", format!(" • Evaluating '{}/{}'...", request.program_id(), request.function_name()));
 
         // Retrieve the stack.
         let stack = self.get_stack(request.program_id())?;
diff --git a/synthesizer/process/src/execute.rs b/synthesizer/process/src/execute.rs
@@ -30,8 +30,7 @@ impl<N: Network> Process<N> {
         // Construct the locator.
         let locator = Locator::new(*request.program_id(), *request.function_name());
 
-        #[cfg(feature = "aleo-cli")]
-        println!("{}", format!(" • Executing '{locator}'...",).dimmed());
+        dev_println!("{}", format!(" • Executing '{locator}'...",));
 
         // The root request does not have a caller.
         let caller = None;
diff --git a/synthesizer/process/src/finalize.rs b/synthesizer/process/src/finalize.rs
@@ -224,8 +224,7 @@ fn finalize_constructor<N: Network, P: FinalizeStorage<N>>(
 ) -> Result<Vec<FinalizeOperation<N>>> {
     // Retrieve the program ID.
     let program_id = stack.program_id();
-    #[cfg(debug_assertions)]
-    println!("Finalizing constructor for {}...", stack.program_id());
+    dev_println!("Finalizing constructor for {}...", stack.program_id());
 
     // Initialize a list for finalize operations.
     let mut finalize_operations = Vec::new();
@@ -286,8 +285,7 @@ fn finalize_transition<N: Network, P: FinalizeStorage<N>>(
     // Retrieve the function name.
     let function_name = transition.function_name();
 
-    #[cfg(debug_assertions)]
-    println!("Finalizing transition for {}/{function_name}...", transition.program_id());
+    dev_println!("Finalizing transition for {}/{function_name}...", transition.program_id());
     debug_assert_eq!(stack.program_id(), transition.program_id());
 
     // If the last output of the transition is a future, retrieve and finalize it. Otherwise, there are no operations to finalize.
diff --git a/synthesizer/process/src/lib.rs b/synthesizer/process/src/lib.rs
@@ -73,7 +73,7 @@ use snarkvm_synthesizer_program::{
     StackTrait,
 };
 use snarkvm_synthesizer_snark::{ProvingKey, UniversalSRS, VerifyingKey};
-use snarkvm_utilities::defer;
+use snarkvm_utilities::{defer, dev_println};
 
 use aleo_std::prelude::{finish, lap, timer};
 use indexmap::IndexMap;
@@ -83,9 +83,6 @@ use locktick::parking_lot::RwLock;
 use parking_lot::RwLock;
 use std::{collections::HashMap, sync::Arc};
 
-#[cfg(feature = "aleo-cli")]
-use colored::Colorize;
-
 #[derive(Clone)]
 pub struct Process<N: Network> {
     /// The universal SRS.
diff --git a/synthesizer/process/src/stack/call/mod.rs b/synthesizer/process/src/stack/call/mod.rs
@@ -29,6 +29,7 @@ use snarkvm_synthesizer_program::{
     RegistersTrait as _,
     StackTrait,
 };
+use snarkvm_utilities::dev_eprintln;
 
 pub trait CallTrait<N: Network> {
     /// Evaluates the instruction.
@@ -448,8 +449,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
                             substack.execute_function::<A, R>(registers.call_stack(), console_caller, root_tvk, rng)?;
                         // Ensure the values are equal.
                         if console_response.outputs() != response.outputs() {
-                            #[cfg(debug_assertions)]
-                            eprintln!("\n{:#?} != {:#?}\n", console_response.outputs(), response.outputs());
+                            dev_eprintln!("\n{:#?} != {:#?}\n", console_response.outputs(), response.outputs());
                             bail!("Function '{}' outputs do not match in a 'call' instruction.", function.name())
                         }
                         // Return the request and response.
diff --git a/synthesizer/process/src/stack/deploy.rs b/synthesizer/process/src/stack/deploy.rs
@@ -104,6 +104,7 @@ impl<N: Network> Stack<N> {
 
         #[cfg(not(any(test, feature = "test")))]
         // Skip the certificate verification if the consensus version is before ConsensusVersion::V8.
+        // Circuit synthesis was changed in a backwards incompatible way in ConsensusVersion::V8.
         if (ConsensusVersion::V1..=ConsensusVersion::V7).contains(&_consensus_version) {
             finish!(timer);
             return Ok(());
diff --git a/synthesizer/process/src/stack/register_types/initialize.rs b/synthesizer/process/src/stack/register_types/initialize.rs
@@ -287,15 +287,17 @@ impl<N: Network> RegisterTypes<N> {
     /// Ensure the given output register is well-formed.
     #[inline]
     fn check_output(&self, stack: &Stack<N>, operand: &Operand<N>, register_type: &RegisterType<N>) -> Result<()> {
-        #[cfg(feature = "aleo-cli")]
         match operand {
             // Inform the user the output operand is an input register, to ensure this is intended behavior.
             Operand::Register(register) if self.is_input(register) => {
-                eprintln!("Output {operand} in '{}' is an input register, ensure this is intended", stack.program_id())
+                dev_eprintln!(
+                    "Output {operand} in '{}' is an input register, ensure this is intended",
+                    stack.program_id()
+                );
             }
             // Inform the user the output operand is a literal, to ensure this is intended behavior.
             Operand::Literal(..) => {
-                eprintln!("Output {operand} in '{}' is a literal, ensure this is intended", stack.program_id())
+                dev_eprintln!("Output {operand} in '{}' is a literal, ensure this is intended", stack.program_id());
             }
             // Otherwise, do nothing.
             _ => (),
diff --git a/synthesizer/process/src/stack/register_types/mod.rs b/synthesizer/process/src/stack/register_types/mod.rs
@@ -47,6 +47,7 @@ use snarkvm_synthesizer_program::{
     Program,
     StackTrait,
 };
+use snarkvm_utilities::dev_eprintln;
 
 use indexmap::{IndexMap, IndexSet};
 
diff --git a/synthesizer/process/src/verify_execution.rs b/synthesizer/process/src/verify_execution.rs
@@ -69,8 +69,7 @@ impl<N: Network> Process<N> {
 
         // Verify each transition.
         for transition in execution.transitions() {
-            #[cfg(debug_assertions)]
-            println!("Verifying transition for {}/{}...", transition.program_id(), transition.function_name());
+            dev_println!("Verifying transition for {}/{}...", transition.program_id(), transition.function_name());
             // Debug-mode only, as the `Transition` constructor recomputes the transition ID at initialization.
             debug_assert_eq!(
                 **transition.id(),
@@ -261,8 +260,7 @@ impl<N: Network> Process<N> {
         // [Inputs] Extend the verifier inputs with the output IDs.
         inputs.extend(transition.outputs().iter().flat_map(|output| output.verifier_inputs()));
 
-        #[cfg(debug_assertions)]
-        println!("Transition public inputs ({} elements): {:#?}", inputs.len(), inputs);
+        dev_println!("Transition public inputs ({} elements): {:#?}", inputs.len(), inputs);
         Ok(inputs)
     }
 }
diff --git a/synthesizer/process/src/verify_fee.rs b/synthesizer/process/src/verify_fee.rs
@@ -34,9 +34,10 @@ impl<N: Network> Process<N> {
         // Retrieve the function from the stack.
         let function = stack.get_function(fee.function_name())?;
 
+        dev_println!("Verifying fee from {}/{}...", fee.program_id(), fee.function_name());
+
         #[cfg(debug_assertions)]
         {
-            println!("Verifying fee from {}/{}...", fee.program_id(), fee.function_name());
             // Ensure the number of function calls in this function is 1.
             if stack.get_number_of_calls(function.name())? != 1 {
                 bail!("The number of function calls in '{}/{}' should be 1", stack.program_id(), function.name())
@@ -168,8 +169,7 @@ impl<N: Network> Process<N> {
         inputs.extend(fee.outputs().iter().flat_map(|output| output.verifier_inputs()));
         lap!(timer, "Construct the verifier inputs");
 
-        #[cfg(debug_assertions)]
-        println!("Fee public inputs ({} elements): {:#?}", inputs.len(), inputs);
+        dev_println!("Fee public inputs ({} elements): {:#?}", inputs.len(), inputs);
 
         // Retrieve the verifying key.
         let verifying_key = stack.get_verifying_key(fee.function_name())?;
@@ -246,8 +246,7 @@ impl<N: Network> Process<N> {
         inputs.extend(fee.outputs().iter().flat_map(|output| output.verifier_inputs()));
         lap!(timer, "Construct the verifier inputs");
 
-        #[cfg(debug_assertions)]
-        println!("Fee public inputs ({} elements): {:#?}", inputs.len(), inputs);
+        dev_println!("Fee public inputs ({} elements): {:#?}", inputs.len(), inputs);
 
         // Retrieve the verifying key.
         let verifying_key = stack.get_verifying_key(fee.function_name())?;
diff --git a/synthesizer/snark/Cargo.toml b/synthesizer/snark/Cargo.toml
@@ -25,8 +25,8 @@ edition = "2024"
 
 [features]
 default = [ ]
-aleo-cli = [ "colored" ]
 cuda = [ "snarkvm-algorithms/cuda" ]
+dev-print = [ "snarkvm-utilities/dev-print" ]
 serial = [ "snarkvm-console/serial", "snarkvm-algorithms/serial" ]
 wasm = [ "snarkvm-console/wasm" ]
 
@@ -41,12 +41,11 @@ features = [ "network" ]
 [dependencies.snarkvm-algorithms]
 workspace = true
 
-[dependencies.bincode]
+[dependencies.snarkvm-utilities]
 workspace = true
 
-[dependencies.colored]
+[dependencies.bincode]
 workspace = true
-optional = true
 
 [dependencies.serde_json]
 workspace = true
diff --git a/synthesizer/snark/src/certificate/mod.rs b/synthesizer/snark/src/certificate/mod.rs
@@ -33,11 +33,10 @@ impl<N: Network> Certificate<N> {
 
     /// Returns the certificate from the proving and verifying key.
     pub fn certify(
-        function_name: &str,
+        _function_name: &str,
         proving_key: &ProvingKey<N>,
         verifying_key: &VerifyingKey<N>,
     ) -> Result<Certificate<N>> {
-        #[cfg(feature = "aleo-cli")]
         let timer = std::time::Instant::now();
 
         // Retrieve the proving parameters.
@@ -47,20 +46,19 @@ impl<N: Network> Certificate<N> {
         // Compute the certificate.
         let certificate = Varuna::<N>::prove_vk(universal_prover, fiat_shamir, verifying_key, proving_key)?;
 
-        #[cfg(feature = "aleo-cli")]
-        println!("{}", format!(" • Certified '{function_name}': {} ms", timer.elapsed().as_millis()).dimmed());
+        let _elapsed = timer.elapsed().as_millis();
+        dev_println!(" • Certified '{_function_name}' (in {_elapsed} ms)");
 
         Ok(Self::new(certificate))
     }
 
     /// Returns the certificate from the proving and verifying key.
     pub fn verify(
         &self,
-        function_name: &str,
+        _function_name: &str,
         assignment: &circuit::Assignment<N::Field>,
         verifying_key: &VerifyingKey<N>,
     ) -> bool {
-        #[cfg(feature = "aleo-cli")]
         let timer = std::time::Instant::now();
 
         // Retrieve the verification parameters.
@@ -71,17 +69,12 @@ impl<N: Network> Certificate<N> {
         #[allow(clippy::manual_unwrap_or_default)]
         match Varuna::<N>::verify_vk(universal_verifier, fiat_shamir, assignment, verifying_key, self) {
             Ok(is_valid) => {
-                #[cfg(feature = "aleo-cli")]
-                {
-                    let elapsed = timer.elapsed().as_millis();
-                    println!("{}", format!(" • Verified certificate for '{function_name}': {elapsed} ms").dimmed());
-                }
-
+                let _elapsed = timer.elapsed().as_millis();
+                dev_println!(" • Verified certificate for '{_function_name}' (in {_elapsed} ms)");
                 is_valid
             }
-            Err(error) => {
-                #[cfg(feature = "aleo-cli")]
-                println!("{}", format!(" • Certificate verification failed: {error}").dimmed());
+            Err(_error) => {
+                dev_println!(" • Certificate verification on network {} failed: {_error}", N::NAME);
                 false
             }
         }
diff --git a/synthesizer/snark/src/lib.rs b/synthesizer/snark/src/lib.rs
@@ -16,19 +16,16 @@
 #![forbid(unsafe_code)]
 #![allow(clippy::too_many_arguments)]
 #![warn(clippy::cast_possible_truncation)]
-#![cfg_attr(not(feature = "aleo-cli"), allow(unused_variables))]
 
 extern crate snarkvm_circuit as circuit;
 extern crate snarkvm_console as console;
 
 use console::network::{FiatShamir, prelude::*};
 use snarkvm_algorithms::{snark::varuna, traits::SNARK};
+use snarkvm_utilities::dev_println;
 
 use std::sync::{Arc, OnceLock};
 
-#[cfg(feature = "aleo-cli")]
-use colored::Colorize;
-
 type Varuna<N> = varuna::VarunaSNARK<<N as Environment>::PairingCurve, FiatShamir<N>, varuna::VarunaHidingMode>;
 
 mod certificate;
diff --git a/synthesizer/snark/src/proving_key/mod.rs b/synthesizer/snark/src/proving_key/mod.rs
diff --git a/synthesizer/snark/src/universal_srs.rs b/synthesizer/snark/src/universal_srs.rs
diff --git a/synthesizer/snark/src/verifying_key/mod.rs b/synthesizer/snark/src/verifying_key/mod.rs
diff --git a/vm/package/build.rs b/vm/package/build.rs
diff --git a/vm/package/deploy.rs b/vm/package/deploy.rs
diff --git a/vm/package/execute.rs b/vm/package/execute.rs
diff --git a/vm/package/mod.rs b/vm/package/mod.rs
diff --git a/vm/package/run.rs b/vm/package/run.rs

Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,6 @@ pub enum SNARKError {`
`44`	`44`
`45`	`45`	`#[error("Public input size was different from the circuit")]`
`46`	`46`	`PublicInputSizeMismatch,`
`47`		`-`
`48`		`- #[error("Circuit not found")]`
`49`		`- CircuitNotFound,`
`50`	`47`	`}`
`51`	`48`
`52`	`49`	`impl From<AHPError> for SNARKError {`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@ locktick = [`
`31`	`31`	`"snarkvm-ledger-store/locktick",`
`32`	`32`	`"snarkvm-synthesizer-process/locktick"`
`33`	`33`	`]`
`34`		`-aleo-cli = [ ]`
`35`	`34`	`async = [ "snarkvm-ledger-query/async", "snarkvm-synthesizer-process/async" ]`
`36`	`35`	`cuda = [ "snarkvm-algorithms/cuda" ]`
`37`	`36`	`history = [ "serde" ]`