Compute size of Execution proof without needing to compute the proof

[Antonio95]

Currently Execution storage costs are computed by generating a proof for the Authorization and checking its size, which creates an undesirable double-proving workflow (because the storage cost is an input when computing the fee-transaction proof). This PR adds:

• A method which, given a list of batch sizes, computes the size of the corresponding (batched) Varuna proof.
• An Authorization::proof_size method which computes the size of the Varuna proof for self by calculating the expected batch sizes and then calling the method above.
• A consistency check to ensure the inclusion batch size from the method above coincides with that in prepare_verifier_inputs (for futureproofing)
• An update of existing execution tests to VarunaVersion::V2 and the addition to those tests of a proof-size check (i. e. ensuring that the size of the serialized proof, once computed, coincides with the predicted size given the Authorization). In the tested cases, the predicted size is an exact match.

Since testing has happened only for a limited time of example Authorizations available in the code, any issues should be reported when this starts being tested in more complex, real-world Authorizations.

[Copilot]

Pull Request Overview

This PR implements a method to compute the size of Execution proofs without needing to generate the actual proof, addressing the double-proving workflow issue where storage costs are computed by generating proofs. The key changes include:

• Adding a proof size prediction method for Varuna proofs based on batch sizes
• Implementing an Authorization::proof_size method that calculates expected batch sizes and predicts proof size
• Adding consistency checks between predicted and actual batch sizes
• Updating existing tests to use VarunaVersion::V2 and verify proof size predictions match actual serialized proof sizes

Reviewed Changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
synthesizer/process/src/trace/mod.rs	Adds consistency check for inclusion batch sizes and makes transitions iterator cloneable
synthesizer/process/src/tests/test_execute.rs	Updates tests to use VarunaVersion::V2 and adds proof size validation checks
synthesizer/process/src/stack/authorization/mod.rs	Implements proof_size method and number_of_input_records helper for Authorization
ledger/block/src/transaction/execution/mod.rs	Makes transitions iterator cloneable to support new functionality
algorithms/src/snark/varuna/tests.rs	Adds proof size validation test for Varuna V2
algorithms/src/snark/varuna/data_structures/proof.rs	Implements proof_size function to calculate Varuna proof size without generating proof

---

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

[Antonio95]

(converted to draft due to likely conflicts with PR #2948 , fixing soon)

[vicsn]

LGTM besides the documentation nits

[d0cd]

Suggested change

	// - batch sizes: (boils down to CanonicalSerialize for [usize])
	// + one u64 for the length (the number of circuits) followed that many usize
	// This contains the size information for the vectors in all other fields,
	// which are therefore serialised without their length
	// - batch sizes: one `usize` for each batch size plus one `u64` for the number of batches.
	// This contains the size information for all other vectors in the `Proof`, allowing them to be serialized without a length prefix.

[Antonio95]

Addressed

[d0cd]

Suggested change

	/// Returns the (exact) predicted size of the Varuna proof of an Authorization
	/// Returns the size of the Varuna proof of an `Authorization`

[Antonio95]

(function gone in later commits)

[d0cd]

Suggested change

	// The value returned coincides with `Proof<N: Network>::write_le()`, which
	// The value returned is equal to the number of bytes returned by `Proof<N: Network>::write_le()`, which

[Antonio95]

(function gone in later commits)

[d0cd]

Suggested change

	/// Total number of inputs to the passed `Transition`s that are of type
	/// Returns the total number of inputs to the passed `Transition`s that are of type

[Antonio95]

(addressed and also fixed other parts of the same documentation that had become outdated due to the interface change)

[d0cd]

You might not need the second clone of transitions.

[Antonio95]

Thank you, fixed

[Antonio95]

Hi @d0cd! Quite a few things have changed in the last commits:

1. After some discussion with @vicsn, it seems the best interface for the envisioned use cases is

   pub fn execution_cost_for_authorization<N: Network>(
        process: &Process<N>,
        authorization: &Authorization<N>,
        consensus_version: ConsensusVersion,
   )
   

   which has been implemented and placed at the same location and level as

   pub fn execution_cost<N: Network>(
       process: &Process<N>,
       execution: &Execution<N>,
       consensus_version: ConsensusVersion,
   )
   

   Let me know if that looks good or you think there might be a better design (@niklaslong might also have an informed opinion on this).

2. The Authorization::proof_size introduced in the previous commit has been removed, as it is not particularly useful given the new interface from point 1.

3. For some reasons (*) it was convenient to create an auxiliary execution_cost_with_size() which behaved exactly like execution_cost() but received the size of the Execution instead of computing it internally. So this has been added next to execution_cost(), which now wraps around the new function but computes the size of the Execution first. This caused a prototype change in execution_cost_v1(), execution_cost_v2() and execution_cost_v3(), which have been fixed and made private (they were only used in tests). This has all been discussed with Victor.

   (*) The reasons, feel free to skip: because the storage cost is not directly execution.size_in_bytes() but a transformation of that under execution_storage_cost(), the new execution_cost_for_authorization could not simply read the storage cost returned by execution_cost() and add the proof size (because the returned value may have been non-additively modified by execution_storage_cost()). Therefore, on top of calling execution_cost(), execution_cost_for_authorization() would need to also call execution.size_in_bytes() and serialisation would thus happen twice for the same Execution. execution_cost_with_size() was introduced in order to avoid this.

4. None of my previous fee-estimation tests involved Transitions with input records. Victor helped me find some test Executions involving such Transitions in test_vm_execute_and_finalize.rs. Since in that test there is only direct access to the Execution object (not the Authorization), I have created a test-only method

   #[cfg(feature = "test")]
   impl<N: Network> Authorization<N> {
       pub fn from_unchecked((requests, transitions): (Vec<Request<N>>, Vec<Transition<N>>)) -> Self {
           ...
       }
   }
   

   in synthesizer/process/src/stack/authorization/mod.rs in order to avoid having to create the actual Requests corresponding to the Transitions in the Execution.

5. Small important plot twist to point 4: the only test with input records in synthesizer/tests/tests/vm/execute_and_finalize/ is mint_and_split (cf. here), which never actually consumes the records: the two calls to split are meant to fail for different reasons (visible in the expected output here). Therefore, a third call to split has been added to that test which correctly consumes a record.

With the above modifications, execute_fee_for_authorization always predicts the correct cost in all tests (including in the case where a record is consumed).

[d0cd]

Looks good to me overall!
There are a few minor nits on improving the clarity of comments. Your call on if you think these are worth addressing.

[vicsn]

Almost there! Besides fixing the last open comments can you merge in staging?

[vicsn]

I'm still seeing "This branch has conflicts that must be resolved". Can you try: git fetch origin staging && git merge origin/staging

[Antonio95]

I'm still seeing "This branch has conflicts that must be resolved". Can you try: git fetch origin staging && git merge origin/staging

Yes! It's taken some effort to merge (staging had quite a few changes on the same functions I touched in the costs.rs file), but it's done now. I think it's ready to go now!

[vicsn]

LGTM!