[Feature] Complete implementation of program upgradability.

circuit/program/src/data/plaintext/mod.rs

@@ -99,6 +99,31 @@ impl<A: Aleo> From<&Literal<A>> for Plaintext<A> {
     }
 }
 
+// A macro that derives implementations of `From` for arrays of a plaintext literals of various sizes.
+macro_rules! impl_plaintext_from_array {
+    ($element:ident, $($size:literal),+) => {
+        $(
+            impl<A: Aleo> From<[$element<A>; $size]> for Plaintext<A> {
+                fn from(value: [$element<A>; $size]) -> Self {
+                    Self::Array(
+                        value
+                            .into_iter()
+                            .map(|element| Plaintext::from(Literal::$element(element)))
+                            .collect(),
+                        OnceCell::new(),
+                    )
+                }
+            }
+        )+
+    };
+}
+
+// Implement for `[U8<N>, SIZE]` for sizes 1 through 32.
+impl_plaintext_from_array!(
+    U8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+    31, 32
+);
+
 #[cfg(test)]
 mod tests {
     use super::*;

circuit/program/src/request/verify.rs

@@ -20,13 +20,15 @@ impl<A: Aleo> Request<A> {
     /// and the signature is valid.
     ///
     /// Verifies (challenge == challenge') && (address == address') && (serial_numbers == serial_numbers') where:
-    ///     challenge' := HashToScalar(r * G, pk_sig, pr_sig, signer, \[tvk, tcm, function ID, input IDs\])
+    ///     challenge' := HashToScalar(r * G, pk_sig, pr_sig, signer, \[tvk, tcm, function ID, is_root, program checksum?, input IDs\])
+    /// The program checksum must be provided if the program has a constructor and should not be provided otherwise.
     pub fn verify(
         &self,
         input_types: &[console::ValueType<A::Network>],
         tpk: &Group<A>,
         root_tvk: Option<Field<A>>,
         is_root: Boolean<A>,
+        program_checksum: Option<Field<A>>,
     ) -> Boolean<A> {
         // Compute the function ID.
         let function_id = compute_function_id(&self.network_id, &self.program_id, &self.function_name);
@@ -40,6 +42,10 @@ impl<A: Aleo> Request<A> {
         message.push(self.tcm.clone());
         message.push(function_id);
         message.push(is_root);
+        // Add the program checksum to the signature message if it was provided.
+        if let Some(program_checksum) = program_checksum {
+            message.push(program_checksum);
+        }
 
         // Check the input IDs and construct the rest of the signature message.
         let (input_checks, append_to_message) = Self::check_input_ids::<true>(
@@ -61,6 +67,7 @@ impl<A: Aleo> Request<A> {
             None => A::halt("Missing input elements in request verification"),
         }
 
+        // Determine the root transition view key.
         let root_tvk = root_tvk.unwrap_or(Field::<A>::new(Mode::Private, self.tvk.eject_value()));
 
         // Verify the transition public key and commitments are well-formed.
@@ -324,6 +331,7 @@ mod tests {
         num_public: u64,
         num_private: u64,
         num_constraints: u64,
+        set_program_checksum: bool,
     ) -> Result<()> {
         let rng = &mut TestRng::default();
 
@@ -367,9 +375,10 @@ mod tests {
 
             // Sample 'root_tvk'.
             let root_tvk = None;
-
             // Sample 'is_root'.
             let is_root = true;
+            // Sample 'program_checksum'.
+            let program_checksum = set_program_checksum.then(|| console::Field::from_u64(i as u64));
 
             // Compute the signed request.
             let request = console::Request::sign(
@@ -380,18 +389,20 @@ mod tests {
                 &input_types,
                 root_tvk,
                 is_root,
+                program_checksum,
                 rng,
             )?;
-            assert!(request.verify(&input_types, is_root));
+            assert!(request.verify(&input_types, is_root, program_checksum));
 
             // Inject the request into a circuit.
             let tpk = Group::<Circuit>::new(mode, request.to_tpk());
             let request = Request::<Circuit>::new(mode, request);
             let is_root = Boolean::new(mode, is_root);
+            let program_checksum = program_checksum.map(|hash| Field::<Circuit>::new(mode, hash));
 
             Circuit::scope(format!("Request {i}"), || {
                 let root_tvk = None;
-                let candidate = request.verify(&input_types, &tpk, root_tvk, is_root);
+                let candidate = request.verify(&input_types, &tpk, root_tvk, is_root, program_checksum);
                 assert!(candidate.eject_value());
                 match mode.is_constant() {
                     true => assert_scope!(<=num_constants, <=num_public, <=num_private, <=num_constraints),
@@ -425,16 +436,19 @@ mod tests {
         // Note: This is correct. At this (high) level of a program, we override the default mode in the `Record` case,
         // based on the user-defined visibility in the record type. Thus, we have nonzero private and constraint values.
         // These bounds are determined experimentally.
-        check_verify(Mode::Constant, 45000, 0, 22000, 22000)
+        check_verify(Mode::Constant, 43440, 0, 21629, 21656, false)?;
+        check_verify(Mode::Constant, 43440, 0, 21629, 21656, true)
     }
 
     #[test]
     fn test_sign_and_verify_public() -> Result<()> {
-        check_verify(Mode::Public, 40938, 0, 30031, 30062)
+        check_verify(Mode::Public, 40938, 0, 30031, 30062, false)?;
+        check_verify(Mode::Public, 40938, 0, 30546, 30577, true)
     }
 
     #[test]
     fn test_sign_and_verify_private() -> Result<()> {
-        check_verify(Mode::Private, 40938, 0, 30031, 30062)
+        check_verify(Mode::Private, 40938, 0, 30031, 30062, false)?;
+        check_verify(Mode::Private, 40938, 0, 30546, 30577, true)
     }
 }

console/algorithms/benches/bhp.rs

@@ -66,10 +66,30 @@ fn bhp1024(c: &mut Criterion) {
     c.bench_function(&format!("BHP1024 Hash - input size {}", input.len()), |b| b.iter(|| hash.hash(&input)));
 }
 
+fn bhp1024_large(c: &mut Criterion) {
+    const SIZE_IN_BYTES: [usize; 4] =
+        [1_000 /* 1 kB */, 10_000 /* 10 kB */, 100_000 /* 100 kB */, 1_000_000 /* 1 MB */];
+    let rng = &mut TestRng::default();
+
+    // Benchmark the BHP1024 hash function for different input sizes.
+    for size in SIZE_IN_BYTES.iter() {
+        let input = (0..size * 8).map(|_| bool::rand(rng)).collect::<Vec<_>>();
+        c.bench_function(&format!("BHP1024 Hash - input size {size} bytes"), |b| {
+            b.iter(|| BHP1024::<Console>::setup("BHP1024").unwrap().hash(&input))
+        });
+    }
+}
+
 criterion_group! {
     name = bhp;
     config = Criterion::default().sample_size(1000);
     targets = bhp256, bhp512, bhp768, bhp1024
 }
 
-criterion_main!(bhp);
+criterion_group! {
+    name = bhp_large;
+    config = Criterion::default().sample_size(100);
+    targets = bhp1024_large
+}
+
+criterion_main!(bhp, bhp_large);

console/network/Cargo.toml

@@ -41,6 +41,9 @@ workspace = true
 [dependencies.anyhow]
 workspace = true
 
+[dependencies.enum-iterator]
+version = "2.1"
+
 [dependencies.indexmap]
 workspace = true
 

console/network/src/canary_v0.rs

@@ -146,8 +146,6 @@ impl Network for CanaryV0 {
     /// The transmission checksum type.
     type TransmissionChecksum = u128;
 
-    /// The network edition.
-    const EDITION: u16 = 0;
     /// The genesis block coinbase target.
     #[cfg(not(feature = "test_targets"))]
     const GENESIS_COINBASE_TARGET: u64 = (1u64 << 29).saturating_sub(1);
@@ -185,16 +183,8 @@ impl Network for CanaryV0 {
     /// A list of (consensus_version, block_height) pairs indicating when each consensus version takes effect.
     /// Documentation for what is changed at each version can be found in `ConsensusVersion`.
     /// Do not read this directly outside of tests, use `N::CONSENSUS_VERSION_HEIGHTS()` instead.
-    const _CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CONSENSUS_VERSIONS] = [
-        (ConsensusVersion::V1, 0),
-        (ConsensusVersion::V2, 2_900_000),
-        (ConsensusVersion::V3, 4_560_000),
-        (ConsensusVersion::V4, 5_730_000),
-        (ConsensusVersion::V5, 5_780_000),
-        (ConsensusVersion::V6, 6_240_000),
-        (ConsensusVersion::V7, 6_880_000),
-        (ConsensusVersion::V8, 7_565_000),
-    ];
+    const _CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CONSENSUS_VERSIONS] =
+        CANARY_V0_CONSENSUS_VERSION_HEIGHTS;
 
     /// Returns the block height where the the inclusion proof will be updated.
     #[allow(non_snake_case)]

console/network/src/consensus_heights.rs

@@ -0,0 +1,113 @@
+// Copyright (c) 2019-2025 Provable Inc.
+// This file is part of the snarkVM library.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::ConsensusVersion;
+
+/// The consensus version height for `CanaryV0`.
+pub const CANARY_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 9] = [
+    (ConsensusVersion::V1, 0),
+    (ConsensusVersion::V2, 2_900_000),
+    (ConsensusVersion::V3, 4_560_000),
+    (ConsensusVersion::V4, 5_730_000),
+    (ConsensusVersion::V5, 5_780_000),
+    (ConsensusVersion::V6, 6_240_000),
+    (ConsensusVersion::V7, 6_880_000),
+    (ConsensusVersion::V8, 7_565_000),
+    (ConsensusVersion::V9, 999_999_999),
+];
+
+/// The consensus version height for `MainnetV0`.
+pub const MAINNET_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 9] = [
+    (ConsensusVersion::V1, 0),
+    (ConsensusVersion::V2, 2_800_000),
+    (ConsensusVersion::V3, 4_900_000),
+    (ConsensusVersion::V4, 6_135_000),
+    (ConsensusVersion::V5, 7_060_000),
+    (ConsensusVersion::V6, 7_560_000),
+    (ConsensusVersion::V7, 7_570_000),
+    (ConsensusVersion::V8, 9_430_000),
+    (ConsensusVersion::V9, 999_999_999),
+];
+
+/// The consensus version heights for `TestnetV0`.
+pub const TESTNET_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 9] = [
+    (ConsensusVersion::V1, 0),
+    (ConsensusVersion::V2, 2_950_000),
+    (ConsensusVersion::V3, 4_800_000),
+    (ConsensusVersion::V4, 6_625_000),
+    (ConsensusVersion::V5, 6_765_000),
+    (ConsensusVersion::V6, 7_600_000),
+    (ConsensusVersion::V7, 8_365_000),
+    (ConsensusVersion::V8, 9_173_000),
+    (ConsensusVersion::V9, 999_999_999),
+];
+
+/// The consensus version heights when the `test_consensus_heights` feature is enabled.
+pub const TEST_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 9] = [
+    (ConsensusVersion::V1, 0),
+    (ConsensusVersion::V2, 10),
+    (ConsensusVersion::V3, 11),
+    (ConsensusVersion::V4, 12),
+    (ConsensusVersion::V5, 13),
+    (ConsensusVersion::V6, 14),
+    (ConsensusVersion::V7, 15),
+    (ConsensusVersion::V8, 16),
+    (ConsensusVersion::V9, 17),
+];
+
+#[cfg(any(test, feature = "test", feature = "test_consensus_heights"))]
+pub(crate) fn load_test_consensus_heights<N: crate::Network>()
+-> [(ConsensusVersion, u32); crate::NUM_CONSENSUS_VERSIONS] {
+    // Define a closure to verify the consensus heights.
+    let verify_consensus_heights = |heights: &[(ConsensusVersion, u32); crate::NUM_CONSENSUS_VERSIONS]| {
+        // Assert that the genesis height is 0.
+        assert_eq!(heights[0].1, 0, "Genesis height must be 0.");
+        // Assert that the consensus heights are strictly increasing.
+        for window in heights.windows(2) {
+            if window[0] >= window[1] {
+                panic!("Heights must be strictly increasing, but found: {window:?}");
+            }
+        }
+    };
+
+    // Define consensus version heights container used for testing.
+    let mut test_consensus_heights = N::TEST_CONSENSUS_VERSION_HEIGHTS;
+
+    // Check if we can read the heights from an environment variable.
+    match std::env::var("CONSENSUS_VERSION_HEIGHTS") {
+        Ok(height_string) => {
+            // Parse the heights from the environment variable.
+            let parsed_test_consensus_heights: [u32; crate::NUM_CONSENSUS_VERSIONS] = height_string
+                .replace(" ", "")
+                .split(",")
+                .map(|height| height.parse::<u32>().unwrap())
+                .collect::<Vec<u32>>()
+                .try_into()
+                .unwrap();
+            // Set the parsed heights in the test consensus heights.
+            for (i, height) in parsed_test_consensus_heights.into_iter().enumerate() {
+                test_consensus_heights[i] = (N::TEST_CONSENSUS_VERSION_HEIGHTS[i].0, height);
+            }
+            // Verify and return the parsed test consensus heights.
+            verify_consensus_heights(&test_consensus_heights);
+            test_consensus_heights
+        }
+        Err(_) => {
+            // Verify and return the default test consensus heights.
+            verify_consensus_heights(&test_consensus_heights);
+            test_consensus_heights
+        }
+    }
+}