fix(storage): allow getting old blocks from storage

node/src/actors/inventory_manager/handlers.rs

@@ -135,18 +135,27 @@ impl InventoryManager {
             Hash::SHA256(x) => x.to_vec(),
         };
 
-        let fut = storage_mngr::get::<_, Block>(&key)
+        // This closure fills in the missing bytes for backwards-compatibility of blocks encoded
+        // with V1_X using bincode. In particular, it checks whether the serialized bytes contain
+        // staking/unstaking merkle roots
+        let fix = |bytes: Vec<u8>| {
+            if bytes[260..264] == [0x51, 0x00, 0x00, 0x00] {
+                [&bytes[..260], &vec![0u8; 72], &bytes[260..], &vec![0u8; 16]].concat()
+            } else {
+                bytes
+            }
+        };
+
+        // Uses `mapped_get` to alter the bytes before deserialization. Please note that this is
+        // not a proper migration, but rather a workaround that has a little performance penalty
+        let fut = storage_mngr::mapped_get::<_, Block, _>(&key, fix)
             .into_actor(self)
             .then(move |res, _, _| match res {
                 Ok(opt) => match opt {
                     None => fut::err(InventoryManagerError::ItemNotFound),
                     Some(block) => fut::ok(block),
                 },
-                Err(e) => {
-                    log::error!("Couldn't get item from storage: {}", e);
-
-                    fut::err(InventoryManagerError::MailBoxError(e))
-                }
+                Err(e) => fut::err(InventoryManagerError::MailBoxError(e)),
             });
 
         Box::pin(fut)
@@ -390,6 +399,10 @@ impl Handler<GetItemSuperblock> for InventoryManager {
 mod tests {
     use std::sync::Arc;
 
+    use crate::{
+        actors::chain_manager::mining::build_block, config_mngr, storage_mngr,
+        utils::test_actix_system,
+    };
     use witnet_config::config::{Config, StorageBackend};
     use witnet_data_structures::{
         chain::{
@@ -403,11 +416,6 @@ mod tests {
         vrf::BlockEligibilityClaim,
     };
 
-    use crate::{
-        actors::chain_manager::mining::build_block, config_mngr, storage_mngr,
-        utils::test_actix_system,
-    };
-
     use super::*;
 
     const CHECKPOINT_ZERO_TIMESTAMP: i64 = 1_602_666_000;

node/src/storage_mngr.rs

@@ -51,6 +51,21 @@ pub fn get<K, T>(key: &K) -> impl Future<Output = Result<Option<T>, failure::Err
 where
     K: serde::Serialize,
     T: serde::de::DeserializeOwned + 'static,
+{
+    mapped_get(key, |bytes| bytes)
+}
+
+/// Get value associated to a key, with the superpower of mutating the bytes on the fly before
+/// attempting deserialization. This allows for pseudo-migration of data structures that were
+/// stored using a former implementation or serialization method.
+pub fn mapped_get<K, T, F>(
+    key: &K,
+    mapper: F,
+) -> impl Future<Output = Result<Option<T>, failure::Error>>
+where
+    K: serde::Serialize,
+    T: serde::de::DeserializeOwned + 'static,
+    F: FnMut(Vec<u8>) -> Vec<u8>,
 {
     // Check that we don't accidentally use this function with some certain special types
     if TypeId::of::<T>() == TypeId::of::<ChainState>() {
@@ -65,7 +80,7 @@ where
     };
 
     let fut = async move {
-        let opt = addr.send(Get(key_bytes)).await??;
+        let opt = addr.send(Get(key_bytes)).await??.map(mapper);
 
         match opt {
             Some(bytes) => match deserialize(bytes.as_slice()) {