fix(drive)!: invalid protocol version is using to deserialize state

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

@@ -1,14 +1,11 @@
 use crate::abci::handler::error::consensus::AbciResponseInfoGetter;
 use crate::abci::handler::error::HandlerError;
 use crate::error::Error;
-use crate::platform_types::state_transitions_processing_result::{
-    StateTransitionExecutionResult, StateTransitionsProcessingResult,
-};
+use crate::platform_types::state_transitions_processing_result::StateTransitionExecutionResult;
 use dpp::fee::SignedCredits;
 use dpp::version::PlatformVersion;
 use dpp::version::TryIntoPlatformVersioned;
-use tenderdash_abci::proto::abci::tx_record::TxAction;
-use tenderdash_abci::proto::abci::{ExecTxResult, TxRecord};
+use tenderdash_abci::proto::abci::ExecTxResult;
 
 impl TryIntoPlatformVersioned<ExecTxResult> for StateTransitionExecutionResult {
     type Error = Error;

packages/rs-drive-abci/src/execution/engine/initialization/init_chain/v0/mod.rs

@@ -79,6 +79,14 @@ where
 
         state_guard.set_genesis_block_info(Some(genesis_block_info));
 
+        state_guard.set_current_protocol_version_in_consensus(request.initial_protocol_version);
+
+        self.drive.store_current_protocol_version(
+            request.initial_protocol_version,
+            Some(transaction),
+            &platform_version.drive,
+        )?;
+
         if tracing::enabled!(tracing::Level::TRACE) {
             tracing::trace!(
                 platform_state_fingerprint = hex::encode(state_guard.fingerprint()),

packages/rs-drive-abci/src/execution/mod.rs

@@ -4,6 +4,8 @@ mod check_tx;
 pub mod engine;
 /// platform execution events
 pub(in crate::execution) mod platform_events;
+/// Storage implementation for the execution state
+pub mod storage;
 /// Types needed in execution
 pub mod types;
 /// Validation module

packages/rs-drive-abci/src/execution/platform_events/block_end/mod.rs

@@ -1,5 +1,3 @@
-/// Storage of the ephemeral state
-pub(in crate::execution) mod store_ephemeral_state;
 /// Updating the state cache happens as the final part of block finalization
 pub(in crate::execution) mod update_state_cache;
 /// Validator set update

packages/rs-drive-abci/src/execution/platform_events/block_end/update_state_cache/v0/mod.rs

@@ -61,10 +61,12 @@ where
         state_cache.set_genesis_block_info(None);
 
         //todo: verify this with an update
-        PlatformVersion::set_current(PlatformVersion::get(platform_version.protocol_version)?);
+        let version = PlatformVersion::get(platform_version.protocol_version)?;
 
-        // Persist ephemeral data
-        self.store_ephemeral_state(&state_cache, transaction, platform_version)?;
+        PlatformVersion::set_current(version);
+
+        // Persist state cache
+        self.store_platform_state(&state_cache, Some(transaction), platform_version)?;
 
         Ok(())
     }

packages/rs-drive-abci/src/execution/storage/fetch_platform_state/mod.rs

@@ -0,0 +1,32 @@
+use crate::error::execution::ExecutionError;
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use crate::platform_types::platform_state::PlatformState;
+use dpp::version::PlatformVersion;
+use drive::drive::Drive;
+use drive::query::TransactionArg;
+
+mod v0;
+
+impl<C> Platform<C> {
+    /// Fetches execution state from grovedb storage
+    pub fn fetch_platform_state(
+        drive: &Drive,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<Option<PlatformState>, Error> {
+        match platform_version
+            .drive_abci
+            .methods
+            .platform_state_storage
+            .fetch_platform_state
+        {
+            0 => Platform::<C>::fetch_platform_state_v0(drive, transaction, platform_version),
+            version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch {
+                method: "fetch_platform_state".to_string(),
+                known_versions: vec![0],
+                received: version,
+            })),
+        }
+    }
+}

packages/rs-drive-abci/src/execution/storage/fetch_platform_state/v0/mod.rs

@@ -0,0 +1,24 @@
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use crate::platform_types::platform_state::PlatformState;
+use dpp::serialization::PlatformDeserializableFromVersionedStructure;
+use dpp::version::PlatformVersion;
+use drive::drive::Drive;
+use drive::query::TransactionArg;
+
+impl<C> Platform<C> {
+    pub(super) fn fetch_platform_state_v0(
+        drive: &Drive,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<Option<PlatformState>, Error> {
+        drive
+            .fetch_platform_state_bytes(transaction, platform_version)
+            .map_err(Error::Drive)?
+            .map(|bytes| {
+                PlatformState::versioned_deserialize(&bytes, platform_version)
+                    .map_err(Error::Protocol)
+            })
+            .transpose()
+    }
+}

packages/rs-drive-abci/src/execution/storage/mod.rs

@@ -0,0 +1,5 @@
+mod fetch_platform_state;
+mod store_platform_state;
+
+pub use fetch_platform_state::*;
+pub use store_platform_state::*;

packages/rs-drive-abci/src/execution/storage/store_platform_state/mod.rs

@@ -0,0 +1,32 @@
+mod v0;
+
+use crate::error::execution::ExecutionError;
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use crate::platform_types::platform_state::PlatformState;
+use dpp::version::PlatformVersion;
+use drive::query::TransactionArg;
+
+impl<C> Platform<C> {
+    /// Store the execution state in grovedb storage
+    pub fn store_platform_state(
+        &self,
+        state: &PlatformState,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<(), Error> {
+        match platform_version
+            .drive_abci
+            .methods
+            .platform_state_storage
+            .store_platform_state
+        {
+            0 => self.store_platform_state_v0(state, transaction, platform_version),
+            version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch {
+                method: "store_platform_state".to_string(),
+                known_versions: vec![0],
+                received: version,
+            })),
+        }
+    }
+}

packages/rs-drive-abci/src/execution/storage/store_platform_state/v0/mod.rs

@@ -0,0 +1,19 @@
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use crate::platform_types::platform_state::PlatformState;
+use dpp::serialization::PlatformSerializable;
+use dpp::version::PlatformVersion;
+use drive::query::TransactionArg;
+
+impl<C> Platform<C> {
+    pub(super) fn store_platform_state_v0(
+        &self,
+        state: &PlatformState,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<(), Error> {
+        self.drive
+            .store_platform_state_bytes(&state.serialize_to_bytes()?, transaction, platform_version)
+            .map_err(Error::Drive)
+    }
+}

packages/rs-drive-abci/src/main.rs

@@ -372,9 +372,9 @@ mod test {
         let path = tempdir.join("db");
         fs::create_dir(&path).expect("create db dir");
 
-        let platform_version = PlatformVersion::latest();
+        let drive = Drive::open(&path, None).expect("open drive");
 
-        let drive = Drive::open(&path, None, platform_version).expect("open drive");
+        let platform_version = PlatformVersion::latest();
 
         drive
             .create_initial_state_structure(None, platform_version)

packages/rs-drive-abci/src/platform_types/cleaned_abci_messages/request_init_chain_cleaned_params/v0/mod.rs

@@ -34,6 +34,7 @@
 //!
 
 use crate::abci::AbciError;
+use dpp::util::deserializer::ProtocolVersion;
 use drive::dpp::identity::TimestampMillis;
 use serde::{Deserialize, Serialize};
 use tenderdash_abci::proto::abci::RequestInitChain;
@@ -51,6 +52,9 @@ pub struct RequestInitChainCleanedParams {
 
     /// Initial core chain lock height.
     pub initial_core_height: Option<u32>,
+
+    /// Initial protocol version
+    pub initial_protocol_version: ProtocolVersion,
 }
 
 impl TryFrom<RequestInitChain> for RequestInitChainCleanedParams {
@@ -67,10 +71,20 @@ impl TryFrom<RequestInitChain> for RequestInitChainCleanedParams {
             h => Some(h),
         };
 
+        let consensus_params = request.consensus_params.ok_or(AbciError::BadRequest(
+            "consensus params are required in init chain".to_string(),
+        ))?;
+
+        let tenderdash_abci::proto::types::VersionParams { app_version } =
+            consensus_params.version.ok_or(AbciError::BadRequest(
+                "consensus params version is required in init chain".to_string(),
+            ))?;
+
         Ok(Self {
             genesis_time,
             initial_height: request.initial_height as u64,
             initial_core_height,
+            initial_protocol_version: app_version as ProtocolVersion,
         })
     }
 }