Add operation execution status to get_operations command

Signed-off-by: Jean-François Morcillo <[email protected]>

Author: Jean-François Morcillo

massa-api-exports/src/lib.rs

@@ -47,6 +47,25 @@ fn display_if_true(value: bool, text: &str) -> String {
     }
 }
 
+fn display_option_bool(
+    value: Option<bool>,
+    text_true: &str,
+    text_false: &str,
+    text_none: &str,
+) -> String {
+    match value {
+        Some(true) => {
+            format!("[{}]", text_true)
+        }
+        Some(false) => {
+            format!("[{}]", text_false)
+        }
+        None => {
+            format!("[{}]", text_none)
+        }
+    }
+}
+
 /// Just a wrapper with a optional beginning and end
 #[derive(Debug, Deserialize, Clone, Copy, Serialize)]
 pub struct TimeInterval {

massa-api-exports/src/operation.rs

@@ -8,7 +8,7 @@ use massa_models::{
 use massa_signature::{PublicKey, Signature};
 use serde::{Deserialize, Serialize};
 
-use crate::display_if_true;
+use crate::{display_if_true, display_option_bool};
 
 /// operation input
 #[derive(Serialize, Deserialize, Debug)]
@@ -32,21 +32,34 @@ pub struct OperationInfo {
     /// if it appears in multiple blocks, these blocks are in different cliques
     pub in_blocks: Vec<BlockId>,
     /// true if the operation is final (for example in a final block)
-    pub is_final: bool,
+    pub is_operation_final: Option<bool>,
     /// Thread in which the operation can be included
     pub thread: u8,
     /// the operation itself
     pub operation: SecureShareOperation,
+    /// true if the operation execution succeeded, false if failed, None means unknown
+    pub op_exec_status: Option<bool>,
 }
 
 impl std::fmt::Display for OperationInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(
             f,
-            "Operation {}{}{}",
+            "Operation {}{}{}{}",
             self.id,
             display_if_true(self.in_pool, " (in pool)"),
-            display_if_true(self.is_final, " (final)")
+            display_option_bool(
+                self.is_operation_final,
+                " (operation is final)",
+                " (operation is final)",
+                " (finality unkown)"
+            ),
+            display_option_bool(
+                self.op_exec_status,
+                " ( succes)",
+                " ( failed)",
+                " (unkown status)"
+            )
         )?;
         writeln!(f, "In blocks:")?;
         for block_id in &self.in_blocks {

massa-api/src/public.rs

@@ -495,60 +495,64 @@ impl MassaRpcServer for API<Public> {
                 .collect()
         };
 
-        // keep only the ops found in storage
+        // keep only the ops id (found in storage)
         let ops: Vec<OperationId> = storage_info.iter().map(|(op, _)| op.id).collect();
 
-        // ask pool whether it carries the operations
-        let in_pool = self.0.pool_command_sender.contains_operations(&ops);
-
         let api_cfg = self.0.api_settings.clone();
-        let consensus_controller = self.0.consensus_controller.clone();
         if ops.len() as u64 > api_cfg.max_arguments {
             return Err(ApiError::BadRequest("too many arguments".into()).into());
         }
 
-        // check finality by cross-referencing Consensus and looking for final blocks that contain the op
-        let is_final: Vec<bool> = {
-            let involved_blocks: Vec<BlockId> = storage_info
-                .iter()
-                .flat_map(|(_op, bs)| bs.iter())
-                .unique()
-                .cloned()
-                .collect();
+        // ask pool whether it carries the operations
+        let in_pool = self.0.pool_command_sender.contains_operations(&ops);
 
-            let involved_block_statuses = consensus_controller.get_block_statuses(&involved_blocks);
+        let (speculative_op_exec_statuses, final_op_exec_statuses) =
+            self.0.execution_controller.get_op_exec_status();
 
-            let block_statuses: PreHashMap<BlockId, BlockGraphStatus> = involved_blocks
-                .into_iter()
-                .zip(involved_block_statuses.into_iter())
-                .collect();
-            storage_info
-                .iter()
-                .map(|(_op, bs)| {
-                    bs.iter()
-                        .any(|b| block_statuses.get(b) == Some(&BlockGraphStatus::Final))
-                })
-                .collect()
-        };
+        // compute operation finality and operation execution status from *_op_exec_statuses
+        let (is_operation_final, statuses): (Vec<Option<bool>>, Vec<Option<bool>>) = ops
+            .iter()
+            .map(|op| {
+                let is_final = final_op_exec_statuses
+                    .get(op)
+                    .and_then(|status| status.clone());
+                let is_speculative = speculative_op_exec_statuses
+                    .get(op)
+                    .and_then(|status| status.clone());
+                match (is_final, is_speculative) {
+                    (Some(true), _) => (Some(true), Some(true)),
+                    (Some(false), _) => (Some(true), Some(false)),
+                    (None, Some(true)) => (Some(false), Some(true)),
+                    (None, Some(false)) => (Some(false), Some(false)),
+                    (None, None) => (None, None),
+                }
+            })
+            .collect::<Vec<(Option<bool>, Option<bool>)>>()
+            .into_iter()
+            .unzip();
 
         // gather all values into a vector of OperationInfo instances
         let mut res: Vec<OperationInfo> = Vec::with_capacity(ops.len());
         let zipped_iterator = izip!(
             ops.into_iter(),
             storage_info.into_iter(),
             in_pool.into_iter(),
-            is_final.into_iter()
+            is_operation_final.into_iter(),
+            statuses.into_iter(),
         );
-        for (id, (operation, in_blocks), in_pool, is_final) in zipped_iterator {
+        for (id, (operation, in_blocks), in_pool, is_operation_final, op_exec_status) in
+            zipped_iterator
+        {
             res.push(OperationInfo {
                 id,
                 in_pool,
-                is_final,
+                is_operation_final,
                 thread: operation
                     .content_creator_address
                     .get_thread(api_cfg.thread_count),
                 operation,
                 in_blocks: in_blocks.into_iter().collect(),
+                op_exec_status,
             });
         }
 
@@ -1052,3 +1056,34 @@ impl MassaRpcServer for API<Public> {
         openrpc
     }
 }
+
+// check finality by cross-referencing Consensus and looking for final blocks that contain the op
+fn check_consensus_finality(
+    storage_info: &Vec<(SecureShareOperation, PreHashSet<BlockId>)>,
+    consensus_controller: Box<dyn ConsensusController>,
+) -> Vec<(OperationId, bool)> {
+    let involved_blocks: Vec<BlockId> = storage_info
+        .iter()
+        .flat_map(|(_op, bs)| bs.iter())
+        .unique()
+        .cloned()
+        .collect();
+
+    let involved_block_statuses = consensus_controller.get_block_statuses(&involved_blocks);
+
+    let block_statuses: PreHashMap<BlockId, BlockGraphStatus> = involved_blocks
+        .into_iter()
+        .zip(involved_block_statuses.into_iter())
+        .collect();
+
+    storage_info
+        .iter()
+        .map(|(op, bs)| {
+            (
+                op.id,
+                bs.iter()
+                    .any(|b| block_statuses.get(b) == Some(&BlockGraphStatus::Final)),
+            )
+        })
+        .collect()
+}

massa-executed-ops/src/executed_ops.rs

@@ -22,7 +22,7 @@ use nom::{
     IResult, Parser,
 };
 use std::{
-    collections::BTreeMap,
+    collections::{BTreeMap, HashMap},
     ops::Bound::{Excluded, Included, Unbounded},
 };
 
@@ -39,6 +39,8 @@ pub struct ExecutedOps {
     pub ops: PreHashSet<OperationId>,
     /// Accumulated hash of the executed operations
     pub hash: Hash,
+    /// successful operations
+    pub op_exec_status: HashMap<OperationId, bool>,
 }
 
 impl ExecutedOps {
@@ -49,6 +51,7 @@ impl ExecutedOps {
             sorted_ops: BTreeMap::new(),
             ops: PreHashSet::default(),
             hash: Hash::from_bytes(EXECUTED_OPS_HASH_INITIAL_BYTES),
+            op_exec_status: HashMap::new(),
         }
     }
 
@@ -86,7 +89,7 @@ impl ExecutedOps {
     /// Apply speculative operations changes to the final executed operations state
     pub fn apply_changes(&mut self, changes: ExecutedOpsChanges, slot: Slot) {
         self.extend_and_compute_hash(changes.keys());
-        for (op_id, slot) in changes {
+        for (op_id, (op_exec_success, slot)) in changes {
             self.sorted_ops
                 .entry(slot)
                 .and_modify(|ids| {
@@ -97,7 +100,11 @@ impl ExecutedOps {
                     new.insert(op_id);
                     new
                 });
+            if let Some(status) = op_exec_success {
+                self.op_exec_status.insert(op_id, status);
+            }
         }
+        dbg!(&self.op_exec_status);
         self.prune(slot);
     }
 
@@ -113,6 +120,7 @@ impl ExecutedOps {
         for (_, ids) in removed {
             for op_id in ids {
                 self.ops.remove(&op_id);
+                self.op_exec_status.remove(&op_id);
                 self.hash ^= *op_id.get_hash();
             }
         }

massa-executed-ops/src/ops_changes.rs

@@ -1,12 +1,16 @@
 //! Copyright (c) 2022 MASSA LABS <[email protected]>
 
 use massa_models::{
-    operation::{OperationId, OperationIdDeserializer, OperationIdSerializer},
+    operation::{
+        BoolDeserializer, BoolSerializer, OperationId, OperationIdDeserializer,
+        OperationIdSerializer,
+    },
     prehash::PreHashMap,
     slot::{Slot, SlotDeserializer, SlotSerializer},
 };
 use massa_serialization::{
-    Deserializer, SerializeError, Serializer, U64VarIntDeserializer, U64VarIntSerializer,
+    Deserializer, OptionDeserializer, OptionSerializer, SerializeError, Serializer,
+    U64VarIntDeserializer, U64VarIntSerializer,
 };
 use nom::{
     error::{context, ContextError, ParseError},
@@ -16,13 +20,14 @@ use nom::{
 };
 use std::ops::Bound::{Excluded, Included};
 
-/// Speculatives changes for ExecutedOps
-pub type ExecutedOpsChanges = PreHashMap<OperationId, Slot>;
+/// Speculative changes for ExecutedOps
+pub type ExecutedOpsChanges = PreHashMap<OperationId, (Option<bool>, Slot)>;
 
 /// `ExecutedOps` Serializer
 pub struct ExecutedOpsChangesSerializer {
     u64_serializer: U64VarIntSerializer,
     operation_id_serializer: OperationIdSerializer,
+    op_execution: OptionSerializer<bool, BoolSerializer>,
     slot_serializer: SlotSerializer,
 }
 
@@ -38,6 +43,7 @@ impl ExecutedOpsChangesSerializer {
         ExecutedOpsChangesSerializer {
             u64_serializer: U64VarIntSerializer::new(),
             operation_id_serializer: OperationIdSerializer::new(),
+            op_execution: OptionSerializer::new(BoolSerializer::new()),
             slot_serializer: SlotSerializer::new(),
         }
     }
@@ -51,8 +57,10 @@ impl Serializer<ExecutedOpsChanges> for ExecutedOpsChangesSerializer {
     ) -> Result<(), SerializeError> {
         self.u64_serializer
             .serialize(&(value.len() as u64), buffer)?;
-        for (op_id, slot) in value {
+        for (op_id, (op_execution_succeeded, slot)) in value {
             self.operation_id_serializer.serialize(op_id, buffer)?;
+            self.op_execution
+                .serialize(op_execution_succeeded, buffer)?;
             self.slot_serializer.serialize(slot, buffer)?;
         }
         Ok(())
@@ -63,6 +71,7 @@ impl Serializer<ExecutedOpsChanges> for ExecutedOpsChangesSerializer {
 pub struct ExecutedOpsChangesDeserializer {
     u64_deserializer: U64VarIntDeserializer,
     operation_id_deserializer: OperationIdDeserializer,
+    op_execution_deserializer: OptionDeserializer<bool, BoolDeserializer>,
     slot_deserializer: SlotDeserializer,
 }
 
@@ -75,6 +84,7 @@ impl ExecutedOpsChangesDeserializer {
                 Included(max_ops_changes_length),
             ),
             operation_id_deserializer: OperationIdDeserializer::new(),
+            op_execution_deserializer: OptionDeserializer::new(BoolDeserializer::new()),
             slot_deserializer: SlotDeserializer::new(
                 (Included(u64::MIN), Included(u64::MAX)),
                 (Included(0), Excluded(thread_count)),
@@ -98,13 +108,20 @@ impl Deserializer<ExecutedOpsChanges> for ExecutedOpsChangesDeserializer {
                     context("operation id", |input| {
                         self.operation_id_deserializer.deserialize(input)
                     }),
+                    context("operation execution succeeded", |input| {
+                        self.op_execution_deserializer.deserialize(input)
+                    }),
                     context("expiration slot", |input| {
                         self.slot_deserializer.deserialize(input)
                     }),
                 )),
             ),
         )
-        .map(|ids| ids.into_iter().collect())
+        .map(|ids| {
+            ids.into_iter()
+                .map(|(id, op_exec_status, slot)| (id, (op_exec_status, slot)))
+                .collect()
+        })
         .parse(buffer)
     }
 }

massa-execution-exports/src/controller_traits.rs

@@ -51,6 +51,13 @@ pub trait ExecutionController: Send + Sync {
         addresses: &[Address],
     ) -> Vec<(Option<Amount>, Option<Amount>)>;
 
+    fn get_op_exec_status(
+        &self,
+    ) -> (
+        HashMap<OperationId, Option<bool>>,
+        HashMap<OperationId, Option<bool>>,
+    );
+
     /// Get a copy of a single datastore entry with its final and active values
     ///
     /// # Return value

massa-execution-exports/src/test_exports/mock.rs

@@ -222,4 +222,13 @@ impl ExecutionController for MockExecutionController {
     fn clone_box(&self) -> Box<dyn ExecutionController> {
         Box::new(self.clone())
     }
+
+    fn get_op_exec_status(
+        &self,
+    ) -> (
+        HashMap<OperationId, Option<bool>>,
+        HashMap<OperationId, Option<bool>>,
+    ) {
+        (HashMap::new(), HashMap::new())
+    }
 }