feat!: store/fetch reduced platform state in drive

packages/rs-dpp/src/lib.rs

@@ -60,6 +60,7 @@ pub mod voting;
 pub mod core_types;
 
 pub mod group;
+pub mod reduced_platform_state;
 pub mod withdrawal;
 
 pub use async_trait;

packages/rs-dpp/src/reduced_platform_state/mod.rs

@@ -0,0 +1,40 @@
+use crate::reduced_platform_state::v0::ReducedPlatformStateForSavingV0;
+use crate::serialization::{PlatformSerializable, ReducedPlatformDeserializable};
+use crate::ProtocolError;
+use bincode::{config, Decode, Encode};
+use derive_more::From;
+use platform_version::version::PlatformVersion;
+use platform_version::TryIntoPlatformVersioned;
+use serde::{Deserialize, Serialize};
+
+pub mod v0;
+
+/// Reduced Platform State For Saving
+#[derive(Clone, Debug, Encode, Decode)]
+pub enum ReducedPlatformStateForSaving {
+    V0(ReducedPlatformStateForSavingV0),
+}
+
+impl ReducedPlatformDeserializable for ReducedPlatformStateForSaving {
+    type Error = ();
+
+    fn versioned_deserialize(
+        data: &[u8],
+        platform_version: &PlatformVersion,
+    ) -> Result<Self, ProtocolError>
+    where
+        Self: Sized,
+    {
+        let config = config::standard().with_big_endian().with_no_limit();
+        let reduced_platform_state_in_save_format: ReducedPlatformStateForSaving =
+            bincode::decode_from_slice(data, config)
+                .map_err(|e| {
+                    ProtocolError::PlatformDeserializationError(format!(
+                        "unable to deserialize ReducedPlatformStateForSaving: {}",
+                        e
+                    ))
+                })?
+                .0;
+        Ok(reduced_platform_state_in_save_format)
+    }
+}

packages/rs-dpp/src/reduced_platform_state/v0/mod.rs

@@ -0,0 +1,25 @@
+use crate::block::block_info::BlockInfo;
+use crate::block::extended_block_info::ExtendedBlockInfo;
+use crate::fee::default_costs::EpochIndexFeeVersionsForStorage;
+use crate::util::deserializer::ProtocolVersion;
+use bincode::{Decode, Encode};
+use platform_value::Bytes32;
+
+/// Reduced Platform State for Saving V0
+#[derive(Clone, Debug, Encode, Decode)]
+pub struct ReducedPlatformStateForSavingV0 {
+    /// Information about the genesis block
+    pub genesis_block_info: Option<BlockInfo>,
+    /// Information about the last block
+    pub last_committed_block_info: Option<ExtendedBlockInfo>,
+    /// Current Version
+    pub current_protocol_version_in_consensus: ProtocolVersion,
+    /// upcoming protocol version
+    pub next_epoch_protocol_version: ProtocolVersion,
+    /// current quorum
+    pub current_validator_set_quorum_hash: Bytes32,
+    /// next quorum
+    pub next_validator_set_quorum_hash: Option<Bytes32>,
+    /// previous Fee Versions
+    pub previous_fee_versions: EpochIndexFeeVersionsForStorage,
+}

packages/rs-dpp/src/serialization/serialization_traits.rs

@@ -31,6 +31,21 @@ pub trait PlatformSerializable {
     }
 }
 
+pub trait ReducedPlatformSerializable {
+    type Error;
+    fn reduced_serialize_to_bytes(&self) -> Result<Vec<u8>, Self::Error>;
+}
+
+pub trait ReducedPlatformDeserializable {
+    type Error;
+    fn versioned_deserialize(
+        data: &[u8],
+        platform_version: &PlatformVersion,
+    ) -> Result<Self, ProtocolError>
+    where
+        Self: Sized;
+}
+
 pub trait PlatformSerializableWithPlatformVersion {
     type Error;
     /// Version based serialization is done based on the desired structure version.

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

@@ -15,6 +15,7 @@ use dpp::version::PlatformVersion;
 use drive::grovedb::Transaction;
 
 mod v0;
+mod v1;
 
 impl<C> Platform<C>
 where
@@ -161,6 +162,16 @@ Your software version: {}, latest supported protocol version: {}."#,
                 block_platform_version,
                 timer,
             ),
+            1 => self.run_block_proposal_v1(
+                block_proposal,
+                known_from_us,
+                epoch_info,
+                transaction,
+                platform_state,
+                block_platform_state,
+                block_platform_version,
+                timer,
+            ),
             version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch {
                 method: "run_block_proposal".to_string(),
                 known_versions: vec![0],