[Feature] Introduce constructor, Operand::Checksum and Operand::Edition

console/network/src/lib.rs

@@ -129,6 +129,8 @@ pub trait Network:
     const STARTING_SUPPLY: u64 = 1_500_000_000_000_000; // 1.5B credits
     /// The cost in microcredits per byte for the deployment transaction.
     const DEPLOYMENT_FEE_MULTIPLIER: u64 = 1_000; // 1 millicredit per byte
+    /// The multiplier in microcredits for each command in the constructor.
+    const CONSTRUCTOR_FEE_MULTIPLIER: u64 = 100; // 100x per command
     /// The constant that divides the storage polynomial.
     const EXECUTION_STORAGE_FEE_SCALING_FACTOR: u64 = 5000;
     /// The maximum size execution transactions can be before a quadratic storage penalty applies.
@@ -141,7 +143,7 @@ pub trait Network:
     const MAX_DEPLOYMENT_CONSTRAINTS: u64 = 1 << 20; // 1,048,576 constraints
     /// The maximum number of microcredits that can be spent as a fee.
     const MAX_FEE: u64 = 1_000_000_000_000_000;
-    /// The maximum number of microcredits that can be spent on a transaction's finalize scope.
+    /// The maximum number of microcredits that can be spent on a constructor or finalize scope.
     const TRANSACTION_SPEND_LIMIT: u64 = 100_000_000;
 
     /// The anchor height, defined as the expected number of blocks to reach the coinbase target.

ledger/block/src/transaction/merkle.rs

@@ -216,7 +216,7 @@ impl<N: Network> Transaction<N> {
         // Ensure the number of functions is within the allowed range.
         ensure!(
             num_transitions < Self::MAX_TRANSITIONS, // Note: Observe we hold back 1 for the fee.
-            "Execution must contain less than {num_transitions} transitions, found {}",
+            "Execution must contain less than {} transitions, found {num_transitions}",
             Self::MAX_TRANSITIONS,
         );
         Ok(())

ledger/block/src/transactions/confirmed/mod.rs

@@ -27,12 +27,16 @@ pub type NumFinalizeSize = u16;
 #[derive(Clone, PartialEq, Eq)]
 pub enum ConfirmedTransaction<N: Network> {
     /// The accepted deploy transaction is composed of `(index, deploy_transaction, finalize_operations)`.
+    /// The finalize operations may contain operations from the executing the constructor and fee transition.
     AcceptedDeploy(u32, Transaction<N>, Vec<FinalizeOperation<N>>),
     /// The accepted execute transaction is composed of `(index, execute_transaction, finalize_operations)`.
+    /// The finalize operations can contain operations from the executing the finalize scope and fee transition.
     AcceptedExecute(u32, Transaction<N>, Vec<FinalizeOperation<N>>),
     /// The rejected deploy transaction is composed of `(index, fee_transaction, rejected_deployment, finalize_operations)`.
+    /// The finalize operations can contain operations from the fee transition.
     RejectedDeploy(u32, Transaction<N>, Rejected<N>, Vec<FinalizeOperation<N>>),
     /// The rejected execute transaction is composed of `(index, fee_transaction, rejected_execution, finalize_operations)`.
+    /// The finalize operations can contain operations from the fee transition.
     RejectedExecute(u32, Transaction<N>, Rejected<N>, Vec<FinalizeOperation<N>>),
 }
 
@@ -51,20 +55,22 @@ impl<N: Network> ConfirmedTransaction<N> {
             }
         };
 
-        // Count the number of `InitializeMapping` and `UpdateKeyValue` finalize operations.
-        let (num_initialize_mappings, num_update_key_values) =
-            finalize_operations.iter().try_fold((0, 0), |(init, update), operation| match operation {
-                FinalizeOperation::InitializeMapping(..) => Ok((init + 1, update)),
-                FinalizeOperation::UpdateKeyValue(..) => Ok((init, update + 1)),
+        // Count the number of `InitializeMapping` and `*KeyValue` finalize operations.
+        let (num_initialize_mappings, num_key_values) =
+            finalize_operations.iter().try_fold((0, 0), |(init, key_value), operation| match operation {
+                FinalizeOperation::InitializeMapping(..) => Ok((init + 1, key_value)),
+                FinalizeOperation::InsertKeyValue(..) // At the time of writing, `InsertKeyValue` is only used in tests. However, it is added for completeness, as it is a valid operation.
+                | FinalizeOperation::RemoveKeyValue(..)
+                | FinalizeOperation::UpdateKeyValue(..) => Ok((init, key_value + 1)),
                 op => {
                     bail!("Transaction '{}' (deploy) contains an invalid finalize operation ({op})", transaction.id())
                 }
             })?;
 
         // Perform safety checks on the finalize operations.
         {
-            // Ensure the number of finalize operations matches the number of 'InitializeMapping' and 'UpdateKeyValue' finalize operations.
-            if num_initialize_mappings + num_update_key_values != finalize_operations.len() {
+            // Ensure the number of finalize operations matches the number of 'InitializeMapping' and '*KeyValue' finalize operations.
+            if num_initialize_mappings + num_key_values != finalize_operations.len() {
                 bail!(
                     "Transaction '{}' (deploy) must contain '{}' operations",
                     transaction.id(),
@@ -79,14 +85,23 @@ impl<N: Network> ConfirmedTransaction<N> {
                     program.mappings().len(),
                 )
             }
-            // Ensure the number of finalize operations matches the number of 'UpdateKeyValue' finalize operations.
-            if num_update_key_values != fee.num_finalize_operations() {
-                bail!(
-                    "Transaction '{}' (deploy) must contain {} 'UpdateKeyValue' operations (found '{num_update_key_values}')",
-                    transaction.id(),
-                    fee.num_finalize_operations()
-                );
-            }
+            // Ensure the number of fee finalize operations lower bounds the number of '*KeyValue' finalize operations.
+            // The lower bound is due to the fact that constructors can issue '*KeyValue' operations as part of the deployment.
+            ensure!(
+                fee.num_finalize_operations() <= num_key_values,
+                "Transaction '{}' (deploy) must contain at least {} '*KeyValue' operations (found '{num_key_values}')",
+                transaction.id(),
+                fee.num_finalize_operations()
+            );
+            // Ensure the number of fee finalize operations and the number of "write" operations in the constructor upper bounds the number of '*KeyValue' finalize operations.
+            // This is an upper bound because a constructor may contain `branch.*` commands so that a subset of writes are executed.
+            let num_constructor_writes = usize::from(program.constructor().map(|c| c.num_writes()).unwrap_or_default());
+            ensure!(
+                fee.num_finalize_operations().saturating_add(num_constructor_writes) >= num_key_values,
+                "Transaction '{}' (deploy) must contain at most {} '*KeyValue' operations (found '{num_key_values}')",
+                transaction.id(),
+                fee.num_finalize_operations().saturating_add(num_constructor_writes)
+            );
         }
 
         // Return the accepted deploy transaction.

ledger/store/src/program/finalize.rs

@@ -590,11 +590,16 @@ impl<N: Network, P: FinalizeStorage<N>> FinalizeStore<N, P> {
 }
 
 impl<N: Network, P: FinalizeStorage<N>> FinalizeStoreTrait<N> for FinalizeStore<N, P> {
-    /// Returns `true` if the given `program ID` and `mapping name` exist.
+    /// Returns `true` if the given `program ID` and `mapping name` is confirmed to exist.
     fn contains_mapping_confirmed(&self, program_id: &ProgramID<N>, mapping_name: &Identifier<N>) -> Result<bool> {
         self.storage.contains_mapping_confirmed(program_id, mapping_name)
     }
 
+    /// Returns `true` if the given `program ID` and `mapping name` exist.
+    fn contains_mapping_speculative(&self, program_id: &ProgramID<N>, mapping_name: &Identifier<N>) -> Result<bool> {
+        self.storage.contains_mapping_speculative(program_id, mapping_name)
+    }
+
     /// Returns `true` if the given `program ID`, `mapping name`, and `key` exist.
     fn contains_key_speculative(
         &self,