[Feature] Support program upgradability.

.circleci/config.yml

@@ -835,6 +835,16 @@ jobs:
           workspace_member: synthesizer/snark
           cache_key: v1.3.0-rust-1.83.0-snarkvm-synthesizer-snark-cache
 
+  synthesizer-upgrade:
+    docker:
+      - image: cimg/rust:1.83.0 # Attention - Change the MSRV in Cargo.toml and rust-toolchain as well
+    resource_class: << pipeline.parameters.xlarge >>
+    steps:
+      - run_serial:
+          flags: test_vm_upgrade --features=test
+          workspace_member: synthesizer
+          cache_key: v1.3.0-rust-1.83.0-snarkvm-synthesizer-upgrade-cache
+
   utilities:
     docker:
       - image: cimg/rust:1.83.0 # Attention - Change the MSRV in Cargo.toml and rust-toolchain as well
@@ -1018,6 +1028,7 @@ workflows:
       - synthesizer-program-integration-instruction-equal
       - synthesizer-program-integration-instruction-commit
       - synthesizer-snark
+      - synthesizer-upgrade
       - utilities
       - utilities-derives
       - wasm

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

@@ -99,6 +99,32 @@ impl<A: Aleo> From<&Literal<A>> for Plaintext<A> {
     }
 }
 
+// A macro that derives the `From` implementation for an array of literals.
+// The array element type should be generic and so should the size.
+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(all(test, feature = "console"))]
 mod tests {
     use super::*;

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 MiB */];
+    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 {} bytes", size), |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/src/canary_v0.rs

@@ -136,29 +136,29 @@ 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`.
     #[cfg(not(any(test, feature = "test", feature = "test_consensus_heights")))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (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_895_000),
+        (ConsensusVersion::V8, 999_999_999),
     ];
     /// 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`.
     #[cfg(any(test, feature = "test", feature = "test_consensus_heights"))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (ConsensusVersion::V1, 0),
         (ConsensusVersion::V2, 10),
         (ConsensusVersion::V3, 11),
         (ConsensusVersion::V4, 12),
         (ConsensusVersion::V5, 13),
         (ConsensusVersion::V6, 14),
         (ConsensusVersion::V7, 15),
+        (ConsensusVersion::V8, 16),
     ];
-    /// 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);

console/network/src/lib.rs

@@ -87,6 +87,8 @@ pub enum ConsensusVersion {
     V6 = 6,
     /// V7: Update to program rules.
     V7 = 7,
+    /// V8: Support for program upgradability.
+    V8 = 8,
 }
 
 pub trait Network:
@@ -108,8 +110,6 @@ pub trait Network:
     const ID: u16;
     /// The network name.
     const NAME: &'static str;
-    /// The network edition.
-    const EDITION: u16;
 
     /// The function name for the inclusion circuit.
     const INCLUSION_FUNCTION_NAME: &'static str;
@@ -228,7 +228,7 @@ pub trait Network:
 
     /// 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 `N::CONSENSUS_VERSION`
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7];
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8];
     ///  A list of (consensus_version, size) pairs indicating the maximum number of validators in a committee.
     //  Note: This value must **not** decrease without considering the impact on serialization.
     //  Decreasing this value will break backwards compatibility of serialization without explicit

console/network/src/mainnet_v0.rs

@@ -137,29 +137,29 @@ impl Network for MainnetV0 {
     /// 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`.
     #[cfg(not(any(test, feature = "test")))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (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, 999_999_999),
     ];
     /// 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`.
     #[cfg(any(test, feature = "test"))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (ConsensusVersion::V1, 0),
         (ConsensusVersion::V2, 10),
         (ConsensusVersion::V3, 11),
         (ConsensusVersion::V4, 12),
         (ConsensusVersion::V5, 13),
         (ConsensusVersion::V6, 14),
         (ConsensusVersion::V7, 15),
+        (ConsensusVersion::V8, 16),
     ];
-    /// The network edition.
-    const EDITION: u16 = 0;
     /// The genesis block coinbase target.
     #[cfg(not(feature = "test"))]
     const GENESIS_COINBASE_TARGET: u64 = (1u64 << 29).saturating_sub(1);

console/network/src/testnet_v0.rs

@@ -136,29 +136,29 @@ impl Network for TestnetV0 {
     /// 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`.
     #[cfg(not(any(test, feature = "test", feature = "test_consensus_heights")))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (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, 999_999_999),
     ];
     /// 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`.
     #[cfg(any(test, feature = "test", feature = "test_consensus_heights"))]
-    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 7] = [
+    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 8] = [
         (ConsensusVersion::V1, 0),
         (ConsensusVersion::V2, 10),
         (ConsensusVersion::V3, 11),
         (ConsensusVersion::V4, 12),
         (ConsensusVersion::V5, 13),
         (ConsensusVersion::V6, 14),
         (ConsensusVersion::V7, 15),
+        (ConsensusVersion::V8, 16),
     ];
-    /// 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);

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

@@ -57,6 +57,32 @@ impl<N: Network> From<&Literal<N>> for Plaintext<N> {
     }
 }
 
+// A macro that derives the `From` implementation for an array of literals.
+// The array element type should be generic and so should the size.
+macro_rules! impl_plaintext_from_array {
+    ($element:ident, $($size:literal),+) => {
+        $(
+            impl<N: Network> From<[$element<N>; $size]> for Plaintext<N> {
+                fn from(value: [$element<N>; $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::*;

console/program/src/state_path/configuration/mod.rs

@@ -57,15 +57,16 @@ pub type TransactionsTree<N> = BHPMerkleTree<N, TRANSACTIONS_DEPTH>;
 /// The Merkle path for a transaction in a block.
 pub type TransactionsPath<N> = MerklePath<N, TRANSACTIONS_DEPTH>;
 
-/// The Merkle tree for the execution.
-pub type ExecutionTree<N> = BHPMerkleTree<N, TRANSACTION_DEPTH>;
-/// The Merkle tree for the deployment.
-pub type DeploymentTree<N> = BHPMerkleTree<N, TRANSACTION_DEPTH>;
 /// The Merkle tree for the transaction.
 pub type TransactionTree<N> = BHPMerkleTree<N, TRANSACTION_DEPTH>;
 /// The Merkle path for a function or transition in the transaction.
 pub type TransactionPath<N> = MerklePath<N, TRANSACTION_DEPTH>;
 
+/// The Merkle tree for the execution.
+pub type ExecutionTree<N> = BHPMerkleTree<N, TRANSACTION_DEPTH>;
+/// The Merkle tree for the deployment.
+pub type DeploymentTree<N> = BHPMerkleTree<N, TRANSACTION_DEPTH>;
+
 /// The Merkle tree for the transition.
 pub type TransitionTree<N> = BHPMerkleTree<N, TRANSITION_DEPTH>;
 /// The Merkle path for an input or output ID in the transition.

ledger/block/src/transaction/bytes.rs

@@ -96,7 +96,8 @@ impl<N: Network> ToBytes for Transaction<N> {
         1u8.write_le(&mut writer)?;
 
         // Write the transaction.
-        // We don't write the deployment or execution id, which are recomputed when creating the transaction.
+        // Note: We purposefully do not write out the deployment or execution ID,
+        // and instead recompute it when reconstructing the transaction, to ensure there was no malleability.
         match self {
             Self::Deploy(id, _, owner, deployment, fee) => {
                 // Write the variant.
@@ -147,8 +148,10 @@ mod tests {
         let rng = &mut TestRng::default();
 
         for expected in [
-            crate::transaction::test_helpers::sample_deployment_transaction(true, rng),
-            crate::transaction::test_helpers::sample_deployment_transaction(false, rng),
+            crate::transaction::test_helpers::sample_deployment_transaction(1, true, rng),
+            crate::transaction::test_helpers::sample_deployment_transaction(1, false, rng),
+            crate::transaction::test_helpers::sample_deployment_transaction(2, true, rng),
+            crate::transaction::test_helpers::sample_deployment_transaction(2, false, rng),
             crate::transaction::test_helpers::sample_execution_transaction_with_fee(true, rng),
             crate::transaction::test_helpers::sample_execution_transaction_with_fee(false, rng),
         ]

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

@@ -18,12 +18,12 @@ use super::*;
 impl<N: Network> FromBytes for Deployment<N> {
     /// Reads the deployment from a buffer.
     fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
-        // Read the version.
-        let version = u8::read_le(&mut reader)?;
-        // Ensure the version is valid.
-        if version != 1 {
-            return Err(error("Invalid deployment version"));
-        }
+        // Read the version and ensure the version is valid.
+        let version = match u8::read_le(&mut reader)? {
+            1 => DeploymentVersion::V1,
+            2 => DeploymentVersion::V2,
+            version => return Err(error(format!("Invalid deployment version: {}", version))),
+        };
 
         // Read the edition.
         let edition = u16::read_le(&mut reader)?;
@@ -45,16 +45,35 @@ impl<N: Network> FromBytes for Deployment<N> {
             verifying_keys.push((identifier, (verifying_key, certificate)));
         }
 
+        // If the deployment version is 2, read the program checksum and verify it.
+        let program_checksum = match version {
+            DeploymentVersion::V1 => None,
+            DeploymentVersion::V2 => {
+                // Read the program checksum.
+                let bytes: [u8; 32] = FromBytes::read_le(&mut reader)?;
+                let checksum = bytes.map(U8::new);
+                // Verify the checksum.
+                if checksum != program.to_checksum() {
+                    return Err(error(format!(
+                        "Invalid checksum in the deployment: expected [{}], got [{}]",
+                        program.to_checksum().iter().join(", "),
+                        checksum.iter().join(", ")
+                    )));
+                }
+                Some(checksum)
+            }
+        };
+
         // Return the deployment.
-        Self::new(edition, program, verifying_keys).map_err(|err| error(format!("{err}")))
+        Self::new(edition, program, verifying_keys, program_checksum).map_err(|err| error(format!("{err}")))
     }
 }
 
 impl<N: Network> ToBytes for Deployment<N> {
     /// Writes the deployment to a buffer.
     fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
         // Write the version.
-        1u8.write_le(&mut writer)?;
+        (self.version() as u8).write_le(&mut writer)?;
         // Write the edition.
         self.edition.write_le(&mut writer)?;
         // Write the program.
@@ -70,6 +89,12 @@ impl<N: Network> ToBytes for Deployment<N> {
             // Write the certificate.
             certificate.write_le(&mut writer)?;
         }
+        // Write the checksum, if it exists.
+        if let Some(program_checksum) = &self.program_checksum {
+            for byte in program_checksum {
+                byte.write_le(&mut writer)?;
+            }
+        }
         Ok(())
     }
 }
@@ -82,12 +107,13 @@ mod tests {
     fn test_bytes() -> Result<()> {
         let rng = &mut TestRng::default();
 
-        // Construct a new deployment.
-        let expected = test_helpers::sample_deployment(rng);
+        // Construct the deployments.
+        for expected in [test_helpers::sample_deployment_v1(rng), test_helpers::sample_deployment_v2(rng)] {
+            // Check the byte representation.
+            let expected_bytes = expected.to_bytes_le()?;
+            assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
+        }
 
-        // Check the byte representation.
-        let expected_bytes = expected.to_bytes_le()?;
-        assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
         Ok(())
     }
 }