Merge branch 'testnet3' into fix/from-bytes-bounds

howardwu · web-flow · commit ebe96d252271 · 2023-11-09T18:10:27.000-08:00
diff --git a/console/program/src/request/serialize.rs b/console/program/src/request/serialize.rs
@@ -21,7 +21,7 @@ impl<N: Network> Serialize for Request<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut transition = serializer.serialize_struct("Request", 9)?;
+                let mut transition = serializer.serialize_struct("Request", 10)?;
                 transition.serialize_field("signer", &self.signer)?;
                 transition.serialize_field("network", &self.network_id)?;
                 transition.serialize_field("program", &self.program_id)?;
diff --git a/ledger/block/src/helpers/target.rs b/ledger/block/src/helpers/target.rs
@@ -27,7 +27,7 @@ pub const fn block_reward(total_supply: u64, block_time: u16, coinbase_reward: u
     // Compute the expected block height at year 1.
     let block_height_at_year_1 = block_height_at_year(block_time, 1);
     // Compute the annual reward: (0.05 * S).
-    let annual_reward = (total_supply / 1000) * 50;
+    let annual_reward = total_supply / 20;
     // Compute the block reward: (0.05 * S) / H_Y1.
     let block_reward = annual_reward / block_height_at_year_1 as u64;
     // Return the sum of the block reward, coinbase reward, and transaction fees.
diff --git a/ledger/block/src/serialize.rs b/ledger/block/src/serialize.rs
@@ -19,7 +19,7 @@ impl<N: Network> Serialize for Block<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut block = serializer.serialize_struct("Block", 6)?;
+                let mut block = serializer.serialize_struct("Block", 7 + self.solutions.is_some() as usize)?;
                 block.serialize_field("block_hash", &self.block_hash)?;
                 block.serialize_field("previous_hash", &self.previous_hash)?;
                 block.serialize_field("header", &self.header)?;
diff --git a/ledger/block/src/transaction/execution/serialize.rs b/ledger/block/src/transaction/execution/serialize.rs
@@ -19,7 +19,7 @@ impl<N: Network> Serialize for Execution<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut execution = serializer.serialize_struct("Execution", 3)?;
+                let mut execution = serializer.serialize_struct("Execution", 2 + self.proof.is_some() as usize)?;
                 execution
                     .serialize_field("transitions", &self.transitions.values().collect::<Vec<&Transition<N>>>())?;
                 execution.serialize_field("global_state_root", &self.global_state_root)?;
diff --git a/ledger/block/src/transaction/fee/serialize.rs b/ledger/block/src/transaction/fee/serialize.rs
@@ -19,7 +19,7 @@ impl<N: Network> Serialize for Fee<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut fee = serializer.serialize_struct("Fee", 3)?;
+                let mut fee = serializer.serialize_struct("Fee", 2 + self.proof.is_some() as usize)?;
                 fee.serialize_field("transition", &self.transition)?;
                 fee.serialize_field("global_state_root", &self.global_state_root)?;
                 if let Some(proof) = &self.proof {
diff --git a/ledger/block/src/transaction/serialize.rs b/ledger/block/src/transaction/serialize.rs
@@ -29,7 +29,7 @@ impl<N: Network> Serialize for Transaction<N> {
                     transaction.end()
                 }
                 Self::Execute(id, execution, fee) => {
-                    let mut transaction = serializer.serialize_struct("Transaction", 4)?;
+                    let mut transaction = serializer.serialize_struct("Transaction", 3 + fee.is_some() as usize)?;
                     transaction.serialize_field("type", "execute")?;
                     transaction.serialize_field("id", &id)?;
                     transaction.serialize_field("execution", &execution)?;
diff --git a/ledger/block/src/transition/input/serialize.rs b/ledger/block/src/transition/input/serialize.rs
@@ -20,7 +20,7 @@ impl<N: Network> Serialize for Input<N> {
         match serializer.is_human_readable() {
             true => match self {
                 Self::Constant(id, value) => {
-                    let mut input = serializer.serialize_struct("Input", 3)?;
+                    let mut input = serializer.serialize_struct("Input", 2 + value.is_some() as usize)?;
                     input.serialize_field("type", "constant")?;
                     input.serialize_field("id", &id)?;
                     if let Some(value) = value {
@@ -29,7 +29,7 @@ impl<N: Network> Serialize for Input<N> {
                     input.end()
                 }
                 Self::Public(id, value) => {
-                    let mut input = serializer.serialize_struct("Input", 3)?;
+                    let mut input = serializer.serialize_struct("Input", 2 + value.is_some() as usize)?;
                     input.serialize_field("type", "public")?;
                     input.serialize_field("id", &id)?;
                     if let Some(value) = value {
@@ -38,7 +38,7 @@ impl<N: Network> Serialize for Input<N> {
                     input.end()
                 }
                 Self::Private(id, value) => {
-                    let mut input = serializer.serialize_struct("Input", 3)?;
+                    let mut input = serializer.serialize_struct("Input", 2 + value.is_some() as usize)?;
                     input.serialize_field("type", "private")?;
                     input.serialize_field("id", &id)?;
                     if let Some(value) = value {
diff --git a/ledger/block/src/transition/output/serialize.rs b/ledger/block/src/transition/output/serialize.rs
@@ -20,7 +20,7 @@ impl<N: Network> Serialize for Output<N> {
         match serializer.is_human_readable() {
             true => match self {
                 Self::Constant(id, value) => {
-                    let mut output = serializer.serialize_struct("Output", 3)?;
+                    let mut output = serializer.serialize_struct("Output", 2 + value.is_some() as usize)?;
                     output.serialize_field("type", "constant")?;
                     output.serialize_field("id", &id)?;
                     if let Some(value) = value {
@@ -29,7 +29,7 @@ impl<N: Network> Serialize for Output<N> {
                     output.end()
                 }
                 Self::Public(id, value) => {
-                    let mut output = serializer.serialize_struct("Output", 3)?;
+                    let mut output = serializer.serialize_struct("Output", 2 + value.is_some() as usize)?;
                     output.serialize_field("type", "public")?;
                     output.serialize_field("id", &id)?;
                     if let Some(value) = value {
@@ -38,7 +38,7 @@ impl<N: Network> Serialize for Output<N> {
                     output.end()
                 }
                 Self::Private(id, value) => {
-                    let mut output = serializer.serialize_struct("Output", 3)?;
+                    let mut output = serializer.serialize_struct("Output", 2 + value.is_some() as usize)?;
                     output.serialize_field("type", "private")?;
                     output.serialize_field("id", &id)?;
                     if let Some(value) = value {
@@ -47,7 +47,7 @@ impl<N: Network> Serialize for Output<N> {
                     output.end()
                 }
                 Self::Record(id, checksum, value) => {
-                    let mut output = serializer.serialize_struct("Output", 5)?;
+                    let mut output = serializer.serialize_struct("Output", 3 + value.is_some() as usize)?;
                     output.serialize_field("type", "record")?;
                     output.serialize_field("id", &id)?;
                     output.serialize_field("checksum", &checksum)?;
@@ -63,7 +63,7 @@ impl<N: Network> Serialize for Output<N> {
                     output.end()
                 }
                 Self::Future(id, value) => {
-                    let mut output = serializer.serialize_struct("Output", 3)?;
+                    let mut output = serializer.serialize_struct("Output", 2 + value.is_some() as usize)?;
                     output.serialize_field("type", "future")?;
                     output.serialize_field("id", &id)?;
                     if let Some(value) = value {
diff --git a/ledger/block/src/verify.rs b/ledger/block/src/verify.rs
@@ -137,16 +137,11 @@ impl<N: Network> Block<N> {
         previous_height: u32,
         current_committee: &Committee<N>,
     ) -> Result<(u64, u32, i64)> {
+        #[cfg(not(any(test, feature = "test")))]
+        ensure!(self.authority.is_quorum(), "The next block must be a quorum block");
+
         // Determine the expected height.
         let expected_height = previous_height.saturating_add(1);
-        // Ensure the block type is correct.
-        match expected_height == 0 {
-            true => ensure!(self.authority.is_beacon(), "The genesis block must be a beacon block"),
-            false => {
-                #[cfg(not(any(test, feature = "test")))]
-                ensure!(self.authority.is_quorum(), "The next block must be a quorum block");
-            }
-        }
 
         // Determine the expected round.
         let expected_round = match &self.authority {
diff --git a/ledger/coinbase/src/helpers/prover_solution/serialize.rs b/ledger/coinbase/src/helpers/prover_solution/serialize.rs
@@ -21,7 +21,8 @@ impl<N: Network> Serialize for ProverSolution<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut prover_solution = serializer.serialize_struct("ProverSolution", 3)?;
+                let mut prover_solution =
+                    serializer.serialize_struct("ProverSolution", 2 + self.proof.random_v.is_some() as usize)?;
                 prover_solution.serialize_field("partial_solution", &self.partial_solution)?;
                 prover_solution.serialize_field("proof.w", &self.proof.w)?;
                 if let Some(random_v) = &self.proof.random_v {
diff --git a/ledger/narwhal/transmission/src/serialize.rs b/ledger/narwhal/transmission/src/serialize.rs
@@ -18,23 +18,25 @@ impl<N: Network> Serialize for Transmission<N> {
     #[inline]
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
-            true => {
-                let mut transmission = serializer.serialize_struct("Transmission", 2)?;
-                match self {
-                    Self::Ratification => {
-                        transmission.serialize_field("type", "ratification")?;
-                    }
-                    Self::Solution(solution) => {
-                        transmission.serialize_field("type", "solution")?;
-                        transmission.serialize_field("transmission", solution)?;
-                    }
-                    Self::Transaction(transaction) => {
-                        transmission.serialize_field("type", "transaction")?;
-                        transmission.serialize_field("transmission", transaction)?;
-                    }
+            true => match self {
+                Self::Ratification => {
+                    let mut transmission = serializer.serialize_struct("Transmission", 1)?;
+                    transmission.serialize_field("type", "ratification")?;
+                    transmission.end()
                 }
-                transmission.end()
-            }
+                Self::Solution(solution) => {
+                    let mut transmission = serializer.serialize_struct("Transmission", 2)?;
+                    transmission.serialize_field("type", "solution")?;
+                    transmission.serialize_field("transmission", solution)?;
+                    transmission.end()
+                }
+                Self::Transaction(transaction) => {
+                    let mut transmission = serializer.serialize_struct("Transmission", 2)?;
+                    transmission.serialize_field("type", "transaction")?;
+                    transmission.serialize_field("transmission", transaction)?;
+                    transmission.end()
+                }
+            },
             false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
         }
     }
diff --git a/ledger/src/lib.rs b/ledger/src/lib.rs
@@ -145,8 +145,9 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         let timer = timer!("Ledger::load_unchecked");
 
         // Initialize the consensus store.
-        let Ok(store) = ConsensusStore::<N, C>::open(dev) else {
-            bail!("Failed to load ledger (run 'snarkos clean' and try again)");
+        let store = match ConsensusStore::<N, C>::open(dev) {
+            Ok(store) => store,
+            Err(e) => bail!("Failed to load ledger (run 'snarkos clean' and try again)\n\n{e}\n"),
         };
         lap!(timer, "Load consensus store");
 
diff --git a/synthesizer/process/src/stack/register_types/initialize.rs b/synthesizer/process/src/stack/register_types/initialize.rs
@@ -305,6 +305,7 @@ impl<N: Network> RegisterTypes<N> {
         operand: &Operand<N>,
         register_type: &RegisterType<N>,
     ) -> Result<()> {
+        #[cfg(feature = "aleo-cli")]
         match operand {
             // Inform the user the output operand is an input register, to ensure this is intended behavior.
             Operand::Register(register) if self.is_input(register) => {
diff --git a/synthesizer/process/src/stack/register_types/matches.rs b/synthesizer/process/src/stack/register_types/matches.rs
@@ -168,8 +168,6 @@ impl<N: Network> RegisterTypes<N> {
     }
 
     /// Checks that the given record matches the layout of the record type.
-    /// Note: Ordering for `owner` **does** matter, however ordering
-    /// for record data does **not** matter, as long as all defined members are present.
     pub fn matches_record(
         &self,
         stack: &(impl StackMatches<N> + StackProgram<N>),
diff --git a/synthesizer/program/src/logic/finalize_operation/serialize.rs b/synthesizer/program/src/logic/finalize_operation/serialize.rs
@@ -19,41 +19,51 @@ impl<N: Network> Serialize for FinalizeOperation<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let mut operation = serializer.serialize_struct("FinalizeOperation", 5)?;
                 // Serialize the components.
                 match self {
                     Self::InitializeMapping(mapping_id) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
                         operation.serialize_field("type", "initialize_mapping")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
+                        operation.end()
                     }
                     Self::InsertKeyValue(mapping_id, key_id, value_id) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 4)?;
                         operation.serialize_field("type", "insert_key_value")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
                         operation.serialize_field("key_id", key_id)?;
                         operation.serialize_field("value_id", value_id)?;
+                        operation.end()
                     }
                     Self::UpdateKeyValue(mapping_id, index, key_id, value_id) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 5)?;
                         operation.serialize_field("type", "update_key_value")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
                         operation.serialize_field("index", index)?;
                         operation.serialize_field("key_id", key_id)?;
                         operation.serialize_field("value_id", value_id)?;
+                        operation.end()
                     }
                     Self::RemoveKeyValue(mapping_id, index) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 3)?;
                         operation.serialize_field("type", "remove_key_value")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
                         operation.serialize_field("index", index)?;
+                        operation.end()
                     }
                     Self::ReplaceMapping(mapping_id) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
                         operation.serialize_field("type", "replace_mapping")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
+                        operation.end()
                     }
                     Self::RemoveMapping(mapping_id) => {
+                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
                         operation.serialize_field("type", "remove_mapping")?;
                         operation.serialize_field("mapping_id", mapping_id)?;
+                        operation.end()
                     }
                 }
-                operation.end()
             }
             false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
         }
diff --git a/synthesizer/src/vm/verify.rs b/synthesizer/src/vm/verify.rs
@@ -255,7 +255,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
 
         // Ensure the fee does not exceed the limit.
         let fee_amount = fee.amount()?;
-        ensure!(*fee_amount < N::MAX_FEE, "Fee verification failed: fee exceeds the maximum limit");
+        ensure!(*fee_amount <= N::MAX_FEE, "Fee verification failed: fee exceeds the maximum limit");
 
         // Verify the fee.
         let verification = self.process.read().verify_fee(fee, deployment_or_execution_id);

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ impl<N: Network> Serialize for Transaction<N> {`
`29`	`29`	`transaction.end()`
`30`	`30`	`}`
`31`	`31`	`Self::Execute(id, execution, fee) => {`
`32`		`- let mut transaction = serializer.serialize_struct("Transaction", 4)?;`
	`32`	`+ let mut transaction = serializer.serialize_struct("Transaction", 3 + fee.is_some() as usize)?;`
`33`	`33`	`transaction.serialize_field("type", "execute")?;`
`34`	`34`	`transaction.serialize_field("id", &id)?;`
`35`	`35`	`transaction.serialize_field("execution", &execution)?;`