Extracting function to calculate block successor offset

nano/lib/blocks.cpp

@@ -1427,6 +1427,34 @@ hashables (error_a, tree_a)
 	}
 }
 
+size_t nano::block::size (nano::block_type type_a)
+{
+	size_t result (0);
+	switch (type_a)
+	{
+		case nano::block_type::invalid:
+		case nano::block_type::not_a_block:
+			assert (false);
+			break;
+		case nano::block_type::send:
+			result = nano::send_block::size;
+			break;
+		case nano::block_type::receive:
+			result = nano::receive_block::size;
+			break;
+		case nano::block_type::change:
+			result = nano::change_block::size;
+			break;
+		case nano::block_type::open:
+			result = nano::open_block::size;
+			break;
+		case nano::block_type::state:
+			result = nano::state_block::size;
+			break;
+	}
+	return result;
+}
+
 void nano::receive_block::hash (blake2b_state & hash_a) const
 {
 	hashables.hash (hash_a);

nano/lib/blocks.hpp

@@ -70,6 +70,7 @@ class block
 	virtual void signature_set (nano::uint512_union const &) = 0;
 	virtual ~block () = default;
 	virtual bool valid_predecessor (nano::block const &) const = 0;
+	static size_t size (nano::block_type);
 };
 class send_hashables
 {

nano/node/lmdb.cpp

@@ -318,7 +318,7 @@ class block_predecessor_set : public nano::block_visitor
 		auto version (store.block_version (transaction, block_a.previous ()));
 		assert (value.mv_size != 0);
 		std::vector<uint8_t> data (static_cast<uint8_t *> (value.mv_data), static_cast<uint8_t *> (value.mv_data) + value.mv_size);
-		std::copy (hash.bytes.begin (), hash.bytes.end (), data.end () - hash.bytes.size ());
+		std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + store.block_successor_offset (transaction, value, type));
 		store.block_raw_put (transaction, store.block_database (type, version), block_a.previous (), nano::mdb_val (data.size (), data.data ()));
 	}
 	void send_block (nano::send_block const & block_a) override
@@ -1299,6 +1299,15 @@ std::shared_ptr<nano::block> nano::mdb_store::block_random (nano::transaction co
 	return result;
 }
 
+size_t nano::mdb_store::block_successor_offset (nano::transaction const &, MDB_val entry_a, nano::block_type type_a)
+{
+	size_t result;
+	// Read old successor-only sideband
+	assert (entry_a.mv_size = nano::block::size (type_a) + sizeof (nano::uint256_union));
+	result = entry_a.mv_size - sizeof (nano::uint256_union);
+	return result;
+}
+
 nano::block_hash nano::mdb_store::block_successor (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
 {
 	nano::block_type type;
@@ -1307,7 +1316,7 @@ nano::block_hash nano::mdb_store::block_successor (nano::transaction const & tra
 	if (value.mv_size != 0)
 	{
 		assert (value.mv_size >= result.bytes.size ());
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (value.mv_data) + value.mv_size - result.bytes.size (), result.bytes.size ());
+		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (value.mv_data) + block_successor_offset (transaction_a, value, type), result.bytes.size ());
 		auto error (nano::read (stream, result.bytes));
 		assert (!error);
 	}

nano/node/lmdb.hpp

@@ -155,6 +155,7 @@ class mdb_store : public block_store
 
 	void initialize (nano::transaction const &, nano::genesis const &) override;
 	void block_put (nano::transaction const &, nano::block_hash const &, nano::block const &, nano::block_hash const & = nano::block_hash (0), nano::epoch version = nano::epoch::epoch_0) override;
+	size_t block_successor_offset (nano::transaction const &, MDB_val, nano::block_type);
 	nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) override;
 	void block_successor_clear (nano::transaction const &, nano::block_hash const &) override;
 	std::shared_ptr<nano::block> block_get (nano::transaction const &, nano::block_hash const &) override;