fix: consensus error is missing in tx results (#1458)

Co-authored-by: QuantumExplorer <[email protected]>

packages/rs-dpp/src/errors/consensus/basic/basic_error.rs

@@ -55,7 +55,7 @@ use crate::consensus::basic::json_schema_error::JsonSchemaError;
 use crate::consensus::basic::unsupported_version_error::UnsupportedVersionError;
 use crate::consensus::basic::value_error::ValueError;
 
-#[derive(Error, Debug, PlatformSerialize, PlatformDeserialize, Encode, Decode)]
+#[derive(Error, Debug, PlatformSerialize, PlatformDeserialize, Encode, Decode, Clone)]
 pub enum BasicError {
     /*
 

packages/rs-dpp/src/errors/consensus/consensus_error.rs

@@ -16,7 +16,7 @@ use crate::errors::consensus::basic::BasicError;
 
 // TODO It must be versioned as all other serializable types
 
-#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize)]
+#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone)]
 #[platform_serialize(limit = 2000)]
 pub enum ConsensusError {
     /*

packages/rs-dpp/src/errors/consensus/fee/fee_error.rs

@@ -6,7 +6,7 @@ use thiserror::Error;
 use crate::errors::ProtocolError;
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 
-#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize)]
+#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone)]
 pub enum FeeError {
     /*
 

packages/rs-dpp/src/errors/consensus/signature/signature_error.rs

@@ -11,7 +11,7 @@ use thiserror::Error;
 use crate::errors::ProtocolError;
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 
-#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize)]
+#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone)]
 pub enum SignatureError {
     /*
 

packages/rs-dpp/src/errors/consensus/state/data_trigger/mod.rs

@@ -12,7 +12,7 @@ pub mod data_trigger_condition_error;
 pub mod data_trigger_execution_error;
 pub mod data_trigger_invalid_result_error;
 
-#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize)]
+#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone)]
 pub enum DataTriggerError {
     /*
 

packages/rs-dpp/src/errors/consensus/state/state_error.rs

@@ -32,7 +32,7 @@ use crate::consensus::state::identity::identity_public_key_already_exists_for_un
 
 use super::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError;
 
-#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize)]
+#[derive(Error, Debug, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone)]
 pub enum StateError {
     /*
 

packages/rs-dpp/src/validation/validation_result.rs

@@ -18,7 +18,7 @@ pub type ConsensusValidationResult<TData> = ValidationResult<TData, ConsensusErr
 
 pub type SimpleConsensusValidationResult = ConsensusValidationResult<()>;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ValidationResult<TData: Clone, E: Debug> {
     pub errors: Vec<E>,
     pub data: Option<TData>,

packages/rs-drive-abci/src/abci/handler/error/consensus.rs

@@ -0,0 +1,37 @@
+use crate::error::Error;
+use dpp::consensus::ConsensusError;
+use dpp::platform_value::platform_value;
+use dpp::platform_value::string_encoding::{encode, Encoding};
+use dpp::serialization::PlatformSerializableWithPlatformVersion;
+use dpp::version::PlatformVersion;
+
+pub trait AbciResponseInfoGetter {
+    /// Returns a base64 encoded consensus error for Tenderdash response info
+    fn response_info_for_version(
+        &self,
+        platform_version: &PlatformVersion,
+    ) -> Result<String, Error>;
+}
+
+impl AbciResponseInfoGetter for ConsensusError {
+    fn response_info_for_version(
+        &self,
+        platform_version: &PlatformVersion,
+    ) -> Result<String, Error> {
+        let consensus_error_bytes = self
+            .serialize_to_bytes_with_platform_version(platform_version)
+            .map_err(Error::Protocol)?;
+
+        let error_data_buffer = platform_value!({
+            "data": {
+                "serializedError": consensus_error_bytes
+            }
+        })
+        .to_cbor_buffer()
+        .map_err(|e| Error::Protocol(e.into()))?;
+
+        let encoded_info = encode(&error_data_buffer, Encoding::Base64);
+
+        Ok(encoded_info)
+    }
+}

packages/rs-drive-abci/src/error/handlers.rs → packages/rs-drive-abci/src/abci/handler/error/mod.rs

@@ -1,3 +1,5 @@
+pub mod consensus;
+
 use crate::error::query::QueryError;
 use crate::error::Error;
 use dpp::platform_value::platform_value;

packages/rs-drive-abci/src/abci/handler/execution_result.rs

@@ -0,0 +1,61 @@
+use crate::abci::handler::error::consensus::AbciResponseInfoGetter;
+use crate::error::Error;
+use crate::platform_types::state_transition_execution_result::StateTransitionExecutionResult;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::fee::SignedCredits;
+use dpp::version::PlatformVersion;
+use dpp::version::TryIntoPlatformVersioned;
+use tenderdash_abci::proto::abci::ExecTxResult;
+
+// State transitions are never free, so we should filter out SuccessfulFreeExecution
+// So we use an option
+impl TryIntoPlatformVersioned<ExecTxResult> for StateTransitionExecutionResult {
+    type Error = Error;
+
+    fn try_into_platform_versioned(
+        self,
+        platform_version: &PlatformVersion,
+    ) -> Result<ExecTxResult, Self::Error> {
+        let response = match self {
+            Self::SuccessfulPaidExecution(dry_run_fee_result, fee_result) => ExecTxResult {
+                code: 0,
+                data: vec![],
+                log: "".to_string(),
+                info: "".to_string(),
+                gas_wanted: dry_run_fee_result.total_base_fee() as SignedCredits,
+                gas_used: fee_result.total_base_fee() as SignedCredits,
+                events: vec![],
+                codespace: "".to_string(),
+            },
+            Self::SuccessfulFreeExecution => ExecTxResult {
+                code: 0,
+                data: vec![],
+                log: "".to_string(),
+                info: "".to_string(),
+                gas_wanted: 0,
+                gas_used: 0,
+                events: vec![],
+                codespace: "".to_string(),
+            },
+            Self::ConsensusExecutionError(validation_result) => {
+                let error = validation_result
+                    .errors
+                    .first()
+                    .expect("invalid execution result should have a consensus error");
+
+                ExecTxResult {
+                    code: error.code(),
+                    data: vec![],
+                    log: "".to_string(),
+                    info: error.response_info_for_version(platform_version)?,
+                    gas_wanted: 0,
+                    gas_used: 0,
+                    events: vec![],
+                    codespace: "".to_string(),
+                }
+            }
+        };
+
+        Ok(response)
+    }
+}