Compute size of Execution proof without needing to compute the proof

algorithms/src/snark/varuna/data_structures/proof.rs

@@ -407,11 +407,10 @@ pub fn proof_size<E: PairingEngine>(
         VarunaVersion::V2 => {
             // All fields are serialised in Compressed mode The breakdown is as
             // follows:
-            // - batch sizes (boils down to CanonicalSerialize for [usize]):
-            //   + one u64 for the length (the number of circuits) followed that many u64,
-            //     which is how usizes are serialized. This contains the size information
-            //     for the vectors in all other fields, which are therefore serialised
-            //     without their length
+            // - batch sizes: one `usize` (which is serialised as a `u64`) for each batch
+            //   size, plus one `u64` for the number of batches. This contains the size
+            //   information for the vectors in all other fields, which are therefore
+            //   serialised without their length prefix.
             // - commitments:
             //   + witness_commitments: n_instances commitments
             //   + mask_poly: 1 byte to encode the enum tag (a bool) plus one commitment if

synthesizer/process/src/cost.rs

@@ -21,9 +21,10 @@ use console::{
     prelude::*,
     program::{FinalizeType, Identifier, LiteralType, PlaintextType},
 };
-use snarkvm_algorithms::snark::varuna::{VarunaVersion, proof_size};
+use snarkvm_algorithms::snark::varuna::VarunaVersion;
 use snarkvm_ledger_block::{Deployment, Execution, Transaction};
 use snarkvm_synthesizer_program::{CastType, Command, Instruction, Operand};
+use snarkvm_synthesizer_snark::proof_size;
 
 /// Returns the deployment cost in microcredits for a given deployment.
 pub fn deployment_cost<N: Network>(
@@ -110,12 +111,14 @@ pub fn execution_cost_for_authorization<N: Network>(
     }
 
     // Varuna is always ran in hiding (i. e. ZK) mode when proving Executions.
-    // If future versions of Varuna are introduced, the correct version should
-    // be deduced from the consensus version. The extra 1 byte comes from the
-    // version number.
-    let expected_proof_size = u64::try_from(1 + proof_size::<N::PairingCurve>(&batch_sizes, VarunaVersion::V2, true)?)?;
+    let hiding_mode = true;
 
-    // We cannot directly add the proof size to the storage cost due to execution_storage_cost()
+    // If future versions of Varuna are introduced, the correct one should be
+    // deduced here from the consensus version. Currently only the latest Varuna
+    // version V2 is supported.
+    let varuna_version = VarunaVersion::V2;
+
+    let expected_proof_size = u64::try_from(proof_size::<N>(&batch_sizes, varuna_version, hiding_mode)?)?;
     let unproved_execution_size = reconstructed_execution.size_in_bytes()?;
     let execution_size = unproved_execution_size.checked_add(expected_proof_size).ok_or(anyhow!(
         "The execution size computation overflowed for an authorization when the proof was taken into account"

synthesizer/process/src/stack/authorization/mod.rs

@@ -286,14 +286,10 @@ impl<N: Network> PartialEq for Authorization<N> {
 impl<N: Network> Eq for Authorization<N> {}
 
 impl<N: Network> Authorization<N> {
-    /// Total number of inputs to the passed `Transition`s that are of type
-    /// `Input::Record`.
-    // This method is used to ensure consistency between
-    // `prepare_verifier_inputs` and the batch-size calculation used in
-    // `Authorization::proof_size` above. The specifics of the former mean this
-    // method must receive an iterator of `Transition`s instead of the
-    // `Authorization` itself. Notably, the `transitions` argument can be
-    // `authorization.transitions().values()`.
+    /// Returns the total number of inputs to the passed `Transition`s that are of
+    /// type `Input::Record`.
+    // This method is used to ensure consistency between `prepare_verifier_inputs`
+    // and the batch-size calculation used in `execution_cost_for_authorization`.
     #[inline]
     pub fn number_of_input_records<'a>(transitions: impl ExactSizeIterator<Item = &'a Transition<N>>) -> usize {
         transitions

synthesizer/process/src/trace/mod.rs

@@ -383,7 +383,7 @@ impl<N: Network> Trace<N> {
         let batch_inclusion_inputs =
             Inclusion::prepare_verifier_inputs(global_state_root, inclusion_version, transitions.clone())?;
 
-        let expected_n_inclusions = Authorization::number_of_input_records(transitions.clone());
+        let expected_n_inclusions = Authorization::number_of_input_records(transitions);
         ensure!(
             batch_inclusion_inputs.len() == expected_n_inclusions,
             "Unexpected number of inclusion inputs: {} instead of {}",

synthesizer/snark/src/lib.rs

@@ -32,7 +32,7 @@ mod certificate;
 pub use certificate::Certificate;
 
 mod proof;
-pub use proof::Proof;
+pub use proof::{Proof, proof_size};
 
 mod proving_key;
 pub use proving_key::ProvingKey;

synthesizer/snark/src/proof/mod.rs

@@ -13,6 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use snarkvm_algorithms::snark::varuna::{VarunaVersion, proof_size as varuna_proof_size};
+
 use super::*;
 
 mod bytes;
@@ -39,3 +41,25 @@ impl<N: Network> Deref for Proof<N> {
         &self.proof
     }
 }
+
+/// Predicts the size in bytes of the proof as produced by
+/// `Proof::serialize_compressed` without needing to receive the proof itself.
+///
+/// *Arguments*:
+///  - `batch_sizes`: the batch sizes of the circuits and instances being
+///    proved.
+///  - `varuna_version`: the version of Varuna being used
+///  - `hiding`: indicates whether the proof system is run in ZK mode
+///
+/// *Returns*:
+///  - `Ok(size)` for `VarunaVersion::V2`, where `size` is the size of the proof
+///    in bytes.
+///  - `Err` for `VarunaVersion::V1`.
+pub fn proof_size<N: Network>(
+    batch_sizes: &[usize],
+    varuna_version: VarunaVersion,
+    hiding_mode: bool,
+) -> Result<usize> {
+    // The extra 1 byte comes from the serialised version number
+    varuna_proof_size::<N::PairingCurve>(batch_sizes, varuna_version, hiding_mode).map(|size| 1 + size)
+}