added limit, checks and abortion reason

Author: Antonio95

console/network/src/consensus_heights.rs

@@ -57,6 +57,7 @@ pub enum ConsensusVersion {
     /// V15: Introduces the record-existence check and `commit.*.raw` instruction variants.
     ///      Increase the anchor time to 35.
     ///      Moves the block's spend limit check to the finalize phase.
+    ///      Introduces block-wide deployment limits.
     V15 = 15,
 }
 

console/network/src/lib.rs

@@ -149,11 +149,21 @@ pub trait Network:
     const EXECUTION_STORAGE_PENALTY_THRESHOLD: u64 = 5000;
     /// The cost in microcredits per constraint for the deployment transaction.
     const SYNTHESIS_FEE_MULTIPLIER: u64 = 25; // 25 microcredits per constraint
-    /// The maximum number of variables in a deployment.
+    /// The maximum number of variables in a deployment. This limit was enforced at the transaction level up to
+    /// consensus version V14 (inclusive). This corresponds to ~0.5 second single-threaded runtime at
+    /// mainnet launch reference validator hardware.
     const MAX_DEPLOYMENT_VARIABLES: u64 = 1 << 21; // 2,097,152 variables
-    /// The maximum number of constraints in a deployment.
+    /// The maximum number of constraints in a deployment. This limit was enforced at the transaction level up to
+    /// consensus version V14 (inclusive). This corresponds to ~0.5 second single-threaded runtime at mainnet
+    /// launch reference validator hardware.
     const MAX_DEPLOYMENT_CONSTRAINTS: u64 = 1 << 21; // 2,097,152 constraints
-    /// The maximum number of instances to verify in a batch proof.
+    /// The maximum number of non-zero entries across all circuits of all deployments in a block. This limit is
+    /// enforced starting at consensus version V15 and overrides the two per-transaction limits above.
+    // TODO (Antonio) make sure this is correct
+    // As an additional sanity check, the total number of constraints and variables of each individual
+    // function is also limited to this bound (at >= V15).
+    // TODO (Antonio) time estimation
+    const MAX_DEPLOY_DENSITY_PER_PROPOSAL: u64 = 1 << 24; // 16,777,216 non-zero entries.
     const MAX_BATCH_PROOF_INSTANCES: usize = 128;
     /// The maximum number of microcredits that can be spent as a fee.
     const MAX_FEE: u64 = 1_000_000_000_000_000;

ledger/block/src/transaction/deployment/mod.rs

@@ -293,6 +293,51 @@ impl<N: Network> Deployment<N> {
         Ok(num_combined_constraints)
     }
 
+    /// Returns the total density of the function and record-translation circuits in this deployment.
+    pub fn combined_density(&self) -> u64 {
+        self.combined_function_density()
+            .saturating_add(self.combined_translation_density())
+    }
+
+    /// Returns the total density of the function circuits in this deployment.
+    pub fn combined_function_density(&self) -> u64 {
+        // Initialize the accumulator.
+        let mut combined_density = 0u64;
+        
+        // Iterate over the function verifying keys.
+        for (_, (vk, _)) in self.function_verifying_keys() {
+            let info = vk.circuit_info;
+            
+            let function_density = (info.num_non_zero_a as u64)
+                .saturating_add(info.num_non_zero_b as u64)
+                .saturating_add(info.num_non_zero_c as u64);
+
+            combined_density = combined_density.saturating_add(function_density);
+        }
+
+        combined_density
+    }
+
+    /// Returns the total density of the record-translation circuits in this deployment.
+    pub fn combined_translation_density(&self) -> u64 {
+        // Initialize the accumulator.
+        let mut combined_density = 0u64;
+
+        // Iterate over the translation verifying keys, if any.
+        if let Some(record_vks) = self.translation_verifying_keys() {
+            for (_, (vk, _)) in record_vks {
+                let info = vk.circuit_info;
+                let circuit_density = (info.num_non_zero_a as u64)
+                    .saturating_add(info.num_non_zero_b as u64)
+                    .saturating_add(info.num_non_zero_c as u64);
+
+                combined_density = combined_density.saturating_add(circuit_density);
+            }
+        }
+
+        combined_density
+    }
+
     /// Returns the deployment ID.
     pub fn to_deployment_id(&self) -> Result<Field<N>> {
         Ok(*Transaction::deployment_tree(self)?.root())

ledger/narwhal/batch-header/src/lib.rs

@@ -351,17 +351,23 @@ mod tests {
 
     #[test]
     fn test_max_synthesis_cost_below_batch_spend_limit() {
-        fn max_synthesis_cost_valid<N: Network>() {
-            let max_synthesis_cost = N::MAX_DEPLOYMENT_VARIABLES.saturating_add(N::MAX_DEPLOYMENT_CONSTRAINTS)
-                * N::SYNTHESIS_FEE_MULTIPLIER
-                / N::ARC_0005_COMPUTE_DISCOUNT;
+        fn max_synthesis_cost_valid<N: Network>(v15_plus: bool) {
+            let max_basis = if v15_plus {
+                N::MAX_DEPLOY_DENSITY_PER_PROPOSAL
+            } else {
+                N::MAX_DEPLOYMENT_VARIABLES.saturating_add(N::MAX_DEPLOYMENT_CONSTRAINTS)
+            };
+            let max_synthesis_cost = max_basis * N::SYNTHESIS_FEE_MULTIPLIER / N::ARC_0005_COMPUTE_DISCOUNT;
             for (_, height) in N::CONSENSUS_VERSION_HEIGHTS().iter() {
                 assert!(max_synthesis_cost < BatchHeader::<N>::batch_spend_limit(*height));
             }
         }
 
-        max_synthesis_cost_valid::<CanaryV0>();
-        max_synthesis_cost_valid::<TestnetV0>();
-        max_synthesis_cost_valid::<MainnetV0>();
+        max_synthesis_cost_valid::<CanaryV0>(false);
+        max_synthesis_cost_valid::<TestnetV0>(false);
+        max_synthesis_cost_valid::<MainnetV0>(false);
+        max_synthesis_cost_valid::<CanaryV0>(true);
+        max_synthesis_cost_valid::<TestnetV0>(true);
+        max_synthesis_cost_valid::<MainnetV0>(true);
     }
 }

synthesizer/process/src/cost.rs

@@ -43,7 +43,9 @@ pub fn deployment_cost<N: Network>(
     deployment: &Deployment<N>,
     consensus_version: ConsensusVersion,
 ) -> Result<(MinimumCost, DeployCostDetails)> {
-    if consensus_version >= ConsensusVersion::V10 {
+    if consensus_version >= ConsensusVersion::V15 {
+        deployment_cost_v3(process, deployment)
+    } else if consensus_version >= ConsensusVersion::V10 {
         deployment_cost_v2(process, deployment)
     } else {
         deployment_cost_v1(process, deployment)
@@ -201,6 +203,66 @@ pub fn execute_compute_cost_in_microcredits(
     }
 }
 
+/// Returns the *minimum* cost in microcredits to publish the given deployment using at `ConsensusVersion::V15` or later.
+// This function only differs from `deployment_cost_v2` in that it replaces the factor (`num_combined_variables` + `num_combined_constraints`)
+// of the synthesis cost by the deployment's combined density.
+pub fn deployment_cost_v3<N: Network>(
+    process: &Process<N>,
+    deployment: &Deployment<N>,
+) -> Result<(MinimumCost, DeployCostDetails)> {
+    // Determine the number of bytes in the deployment.
+    let size_in_bytes = deployment.size_in_bytes()?;
+    // Retrieve the program ID.
+    let program_id = deployment.program_id();
+    // Determine the number of characters in the program ID.
+    let num_characters = u32::try_from(program_id.name().to_string().len())?;
+    // Compute the combined density of all circuits in the deployment.
+    let combined_density = deployment.combined_density();
+
+    // Compute the storage cost in microcredits.
+    let storage_cost = size_in_bytes
+        .checked_mul(N::DEPLOYMENT_FEE_MULTIPLIER)
+        .ok_or(anyhow!("The storage cost computation overflowed for a deployment"))?;
+
+    // Compute the synthesis cost in microcredits.
+    let synthesis_cost = combined_density * N::SYNTHESIS_FEE_MULTIPLIER
+        / N::ARC_0005_COMPUTE_DISCOUNT;
+
+    // Compute a Stack for the deployment.
+    let stack = Stack::new(process, deployment.program())?;
+
+    // Compute the constructor cost in microcredits.
+    let constructor_cost = constructor_cost_in_microcredits_v2(&stack)?;
+
+    // Check that the functions are valid.
+    for function in deployment.program().functions().values() {
+        // Get the finalize cost.
+        let finalize_cost = minimum_cost_in_microcredits_v3(&stack, function.name())?;
+        // Check that the finalize cost does not exceed the maximum.
+        ensure!(
+            finalize_cost <= N::TRANSACTION_SPEND_LIMIT[1].1,
+            "Finalize block '{}' has a cost '{finalize_cost}' which exceeds the transaction spend limit '{}'",
+            function.name(),
+            N::TRANSACTION_SPEND_LIMIT[1].1
+        );
+    }
+
+    // Compute the namespace cost in microcredits: 10^(10 - num_characters) * 1e6
+    let namespace_cost = 10u64
+        .checked_pow(10u32.saturating_sub(num_characters))
+        .ok_or(anyhow!("The namespace cost computation overflowed for a deployment"))?
+        .saturating_mul(1_000_000); // 1 microcredit = 1e-6 credits.
+
+    // Compute the minimum cost in microcredits.
+    let minimum_cost = storage_cost
+        .checked_add(synthesis_cost)
+        .and_then(|x| x.checked_add(constructor_cost))
+        .and_then(|x| x.checked_add(namespace_cost))
+        .ok_or(anyhow!("The total cost computation overflowed for a deployment"))?;
+
+    Ok((minimum_cost, (storage_cost, synthesis_cost, constructor_cost, namespace_cost)))
+}
+
 /// Returns the *minimum* cost in microcredits to publish the given deployment using the ARC_0005_COMPUTE_DISCOUNT.
 pub fn deployment_cost_v2<N: Network>(
     process: &Process<N>,

synthesizer/process/src/stack/deploy.rs

@@ -87,7 +87,7 @@ impl<N: Network> Stack<N> {
     #[inline]
     pub fn verify_deployment<A: circuit::Aleo<Network = N>, R: Rng + CryptoRng>(
         &self,
-        _consensus_version: ConsensusVersion,
+        consensus_version: ConsensusVersion,
         deployment: &Deployment<N>,
         rng: &mut R,
     ) -> Result<()> {
@@ -120,10 +120,12 @@ impl<N: Network> Stack<N> {
         // Get the program ID.
         let program_id = self.program.id();
 
-        // Check that the number of combined variables does not exceed the deployment limit.
-        ensure!(deployment.num_combined_variables()? <= N::MAX_DEPLOYMENT_VARIABLES);
-        // Check that the number of combined constraints does not exceed the deployment limit.
-        ensure!(deployment.num_combined_constraints()? <= N::MAX_DEPLOYMENT_CONSTRAINTS);
+        if consensus_version >= ConsensusVersion::V15 {
+            // Check that the number of combined variables does not exceed the deployment limit.
+            ensure!(deployment.num_combined_variables()? <= N::MAX_DEPLOYMENT_VARIABLES);
+            // Check that the number of combined constraints does not exceed the deployment limit.
+            ensure!(deployment.num_combined_constraints()? <= N::MAX_DEPLOYMENT_CONSTRAINTS);
+        }
 
         // Construct the call stacks and assignments used to verify the certificates.
         let mut call_stacks = Vec::with_capacity(deployment.function_verifying_keys().len());

synthesizer/src/vm/finalize.rs

@@ -428,6 +428,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
                     block_spend,
                     transaction_spend_limit,
                     block_spend_limit,
+                    None,
                     consensus_version,
                 ) {
                     PrepareSpeculateResult::Abort(abort_reason) => {
@@ -957,6 +958,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
         block_spend: u64,
         transaction_spend_limit: u64,
         block_spend_limit: Option<u64>,
+        block_combined_density: Option<u64>,
         consensus_version: ConsensusVersion,
     ) -> PrepareSpeculateResult {
         // Ensure that the transaction is not a fee transaction.
@@ -1028,10 +1030,10 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
             }
         }
 
-        // Before V15, we return without tracking any compute spend.
+        // Before V15, we return without tracking any compute spend and checking deployment limits.
         if consensus_version < ConsensusVersion::V15 {
             PrepareSpeculateResult::Finalize(0)
-        // If the consensus version is >= V15, ensure that the transaction is not exceeding spend limits.
+        // If the consensus version is >= V15, ensure that the transaction is not exceeding spend or deployment limits.
         } else {
             // Compute microcredit spend from deployment or execution cost details.
             let compute_spend = match transaction {
@@ -1068,6 +1070,18 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
                     ));
                 }
             }
+            // If we are keeping track of block-wide circuit density and this transaction contains a deployment, make sure its
+            // density does not make the running total exceed the limit.
+            if let Some(combined_density) = block_combined_density && let Transaction::Deploy(_, _, _, deployment, _) = transaction {
+                if combined_density.saturating_add(deployment.combined_density()) > N::MAX_DEPLOY_DENSITY_PER_PROPOSAL {
+                    return PrepareSpeculateResult::Abort(format!(
+                        "Deployment density '{}' added to current accumulated block-wide density '{}' exceeds the limit '{}'",
+                        deployment.combined_density(),
+                        combined_density,
+                        N::MAX_DEPLOY_DENSITY_PER_PROPOSAL
+                    ));
+                }
+            }
 
             PrepareSpeculateResult::Finalize(compute_spend)
         }
@@ -1100,6 +1114,8 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
             consensus_config_value_by_version!(N, TRANSACTION_SPEND_LIMIT, consensus_version).unwrap();
         // Determine the block spend limit.
         let block_spend_limit = state.block_spend_limit();
+        // Initialize a block-wide total of the combined density of all circuits in all deployments.
+        let mut block_combined_density = 0u64;
 
         // Abort duplicate, overspending, invalid, or disallowed transactions before verification.
         for transaction in transactions.iter() {
@@ -1109,6 +1125,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
                 block_spend,
                 transaction_spend_limit,
                 block_spend_limit,
+                Some(block_combined_density),
                 consensus_version,
             ) {
                 PrepareSpeculateResult::Abort(abort_reason) => {
@@ -1119,6 +1136,14 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
                     if consensus_version >= ConsensusVersion::V15 {
                         // Track the compute_spend used so far.
                         block_spend = block_spend.saturating_add(compute_spend);
+
+                        // If the transaction contains a deployment, add its combined density to the running total.
+                        match transaction {
+                            Transaction::Deploy(_, _, _, deployment, _) => {
+                                block_combined_density = block_combined_density.saturating_add(deployment.combined_density());
+                            },
+                            _ => {}
+                        }
                     }
                     // Track the accepted transaction details.
                     candidate_transaction_details.record_accepted_transaction(transaction);