IPLD block refactor (#146)

Author: sergkaprovich

core/blockchain/block_validator/impl/block_validator_impl.cpp

@@ -9,6 +9,7 @@
 #include "blockchain/block_validator/impl/syntax_rules.hpp"
 #include "codec/cbor/cbor.hpp"
 #include "storage/amt/amt.hpp"
+#include "storage/ipld/ipld_block.hpp"
 
 namespace fc::blockchain::block_validator {
   using primitives::address::Protocol;
@@ -20,6 +21,7 @@ namespace fc::blockchain::block_validator {
   using BlsCryptoPubKey = crypto::bls::PublicKey;
   using SecpCryptoSignature = crypto::secp256k1::Signature;
   using SecpCryptoPubKey = crypto::secp256k1::PublicKey;
+  using IPLDBlock = storage::ipld::IPLDBlock;
 
   const std::map<scenarios::Stage, BlockValidatorImpl::StageExecutor>
       BlockValidatorImpl::stage_executors_{
@@ -151,8 +153,9 @@ namespace fc::blockchain::block_validator {
 
   outcome::result<std::reference_wrapper<BlockValidatorImpl::Tipset>>
   BlockValidatorImpl::getParentTipset(const BlockHeader &block) const {
+    IPLDBlock ipld_block = IPLDBlock::create(block);
     if (parent_tipset_cache_
-        && parent_tipset_cache_.value().first == block.getCID()) {
+        && parent_tipset_cache_.value().first == ipld_block.cid) {
       return parent_tipset_cache_.value().second;
     }
     std::vector<BlockHeader> parent_blocks;
@@ -171,7 +174,7 @@ namespace fc::blockchain::block_validator {
       }
     }
     OUTCOME_TRY(tipset, Tipset::create(parent_blocks));
-    parent_tipset_cache_ = std::make_pair(block.getCID(), std::move(tipset));
+    parent_tipset_cache_ = std::make_pair(std::move(ipld_block.cid), std::move(tipset));
     return parent_tipset_cache_.value().second;
   }
 

core/blockchain/production/impl/block_producer_impl.cpp

@@ -14,6 +14,7 @@
 #include "primitives/cid/cid_of_cbor.hpp"
 #include "storage/amt/amt.hpp"
 #include "storage/ipfs/impl/in_memory_datastore.hpp"
+#include "storage/ipld/ipld_block.hpp"
 
 namespace fc::blockchain::production {
   using clock::Time;
@@ -24,6 +25,7 @@ namespace fc::blockchain::production {
   using storage::amt::Amt;
   using storage::amt::Root;
   using storage::ipfs::InMemoryDatastore;
+  using storage::ipld::IPLDBlock;
   using vm::message::SignedMessage;
   using vm::message::UnsignedMessage;
 
@@ -58,8 +60,8 @@ namespace fc::blockchain::production {
     std::vector<SignedMessage> messages =
         message_storage_->getTopScored(config::kBlockMaxMessagesCount);
     OUTCOME_TRY(msg_meta, getMessagesMeta(messages));
-    OUTCOME_TRY(data_storage_->set(msg_meta.getCID(),
-    msg_meta.getRawBytes()));
+    IPLDBlock msg_meta_block = IPLDBlock::create(msg_meta);
+    OUTCOME_TRY(data_storage_->set(msg_meta_block.cid, msg_meta_block.bytes));
     std::vector<UnsignedMessage> bls_messages;
     std::vector<SignedMessage> secp_messages;
     std::vector<crypto::bls::Signature> bls_signatures;
@@ -88,7 +90,7 @@ namespace fc::blockchain::production {
     header.height = static_cast<uint64_t>(current_epoch);
     header.parent_state_root = std::move(vm_result.state_root);
     header.parent_message_receipts = std::move(vm_result.message_receipts);
-    header.messages = msg_meta.getCID();
+    header.messages = msg_meta_block.cid;
     header.bls_aggregate = std::move(bls_aggregate_sign);
     header.timestamp = static_cast<uint64_t>(now.unixTime().count());
     header.block_sig = {};  // Block must be signed be Actor Miner

core/primitives/block/block.hpp

@@ -19,7 +19,6 @@
 #include "primitives/ticket/epost_ticket_codec.hpp"
 #include "primitives/ticket/ticket.hpp"
 #include "primitives/ticket/ticket_codec.hpp"
-#include "storage/ipld/ipld_block_common.hpp"
 #include "vm/message/message.hpp"
 
 namespace fc::primitives::block {
@@ -28,14 +27,10 @@ namespace fc::primitives::block {
   using primitives::address::Address;
   using primitives::ticket::EPostProof;
   using primitives::ticket::Ticket;
-  using storage::ipld::IPLDBlockCommon;
   using vm::message::SignedMessage;
   using vm::message::UnsignedMessage;
 
-  struct BlockHeader
-      : public IPLDBlockCommon<CID::Version::V1,
-                               storage::ipld::HashType::blake2b_256,
-                               storage::ipld::ContentType::DAG_CBOR> {
+  struct BlockHeader {
     Address miner;
     boost::optional<Ticket> ticket;
     EPostProof epost_proof;
@@ -49,51 +44,11 @@ namespace fc::primitives::block {
     uint64_t timestamp;
     boost::optional<Signature> block_sig;
     uint64_t fork_signaling;
-
-    BlockHeader() = default;
-
-    BlockHeader(Address miner,
-                boost::optional<Ticket> ticket,
-                EPostProof epost_proof,
-                std::vector<CID> parents,
-                BigInt parent_weight,
-                uint64_t height,
-                CID parent_state_root,
-                CID parent_message_receipts,
-                CID messages,
-                Signature bls_aggregate,
-                uint64_t timestamp,
-                boost::optional<Signature> block_sig,
-                uint64_t fork_signaling)
-        : miner{std::move(miner)},
-          ticket{std::move(ticket)},
-          epost_proof{std::move(epost_proof)},
-          parents{std::move(parents)},
-          parent_weight{parent_weight},
-          height{height},
-          parent_state_root{parent_state_root},
-          parent_message_receipts{parent_message_receipts},
-          messages{messages},
-          bls_aggregate{bls_aggregate},
-          timestamp{timestamp},
-          block_sig{block_sig},
-          fork_signaling{fork_signaling} {}
-
-    outcome::result<std::vector<uint8_t>> getBlockContent() const override {
-      return codec::cbor::encode<BlockHeader>(*this);
-    }
   };
 
-  struct MsgMeta
-      : public IPLDBlockCommon<CID::Version::V1,
-                               storage::ipld::HashType::blake2b_256,
-                               storage::ipld::ContentType::DAG_CBOR> {
+  struct MsgMeta {
     CID bls_messages;
     CID secpk_messages;
-
-    outcome::result<std::vector<uint8_t>> getBlockContent() const override {
-      return codec::cbor::encode<MsgMeta>(*this);
-    }
   };
 
   struct Block {

core/storage/amt/amt.hpp

@@ -14,7 +14,6 @@
 #include "common/which.hpp"
 #include "primitives/cid/cid.hpp"
 #include "storage/ipfs/datastore.hpp"
-#include "storage/ipld/ipld_block_common.hpp"
 
 namespace fc::storage::amt {
   enum class AmtError {
@@ -33,7 +32,6 @@ namespace fc::storage::amt {
 
   using common::which;
   using Value = ipfs::IpfsDatastore::Value;
-  using ipld::IPLDBlockCommon;
 
   struct Node {
     using Ptr = std::shared_ptr<Node>;
@@ -119,16 +117,10 @@ namespace fc::storage::amt {
     return s;
   }
 
-  struct Root : public IPLDBlockCommon<CID::Version::V1,
-                                       storage::ipld::HashType::blake2b_256,
-                                       storage::ipld::ContentType::DAG_CBOR> {
+  struct Root {
     uint64_t height{};
     uint64_t count{};
     Node node;
-
-    outcome::result<std::vector<uint8_t>> getBlockContent() const override {
-      return codec::cbor::encode<Root>(*this);
-    }
   };
 
   CBOR_TUPLE(Root, height, count, node)

core/storage/ipld/impl/ipld_node_impl.cpp

@@ -8,7 +8,6 @@
 #include <libp2p/crypto/sha/sha256.hpp>
 #include <libp2p/multi/content_identifier_codec.hpp>
 #include <libp2p/multi/multibase_codec/codecs/base58.hpp>
-#include <libp2p/multi/multihash.hpp>
 #include "ipld_node.pb.h"
 #include "storage/ipld/impl/ipld_node_decoder_pb.hpp"
 
@@ -23,13 +22,22 @@ using Version = libp2p::multi::ContentIdentifier::Version;
 
 namespace fc::storage::ipld {
 
+  const CID &IPLDNodeImpl::getCID() const {
+    return getIPLDBlock().cid;
+  }
+
+  const IPLDNode::Buffer &IPLDNodeImpl::getRawBytes() const {
+    return getIPLDBlock().bytes;
+  }
+
   size_t IPLDNodeImpl::size() const {
     return getRawBytes().size() + child_nodes_size_;
   }
 
   void IPLDNodeImpl::assign(common::Buffer input) {
     content_ = std::move(input);
-    clearCache();
+    ipld_block_ =
+        boost::none;  // Need to recalculate CID after changing Node content
   }
 
   const common::Buffer &IPLDNodeImpl::content() const {
@@ -40,7 +48,8 @@ namespace fc::storage::ipld {
       const std::string &name, std::shared_ptr<const IPLDNode> node) {
     IPLDLinkImpl link{node->getCID(), name, node->size()};
     links_.emplace(name, std::move(link));
-    clearCache();
+    ipld_block_ =
+        boost::none;  // Need to recalculate CID after adding link to child node
     child_nodes_size_ += node->size();
     return outcome::success();
   }
@@ -74,6 +83,10 @@ namespace fc::storage::ipld {
     return link_refs;
   }
 
+  IPLDNode::Buffer IPLDNodeImpl::serialize() const {
+    return Buffer{IPLDNodeEncoderPB::encode(content_, links_)};
+  }
+
   std::shared_ptr<IPLDNode> IPLDNodeImpl::createFromString(
       const std::string &content) {
     std::vector<uint8_t> data{content.begin(), content.end()};
@@ -100,8 +113,11 @@ namespace fc::storage::ipld {
     return node;
   }
 
-  outcome::result<std::vector<uint8_t>> IPLDNodeImpl::getBlockContent() const {
-    return IPLDNodeEncoderPB::encode(content_, links_);
+  const IPLDBlock &IPLDNodeImpl::getIPLDBlock() const {
+    if (!ipld_block_) {
+      ipld_block_ = IPLDBlock::create(*this);
+    }
+    return ipld_block_.value();
   }
 }  // namespace fc::storage::ipld
 

core/storage/ipld/impl/ipld_node_impl.hpp

@@ -14,15 +14,15 @@
 #include <boost/optional.hpp>
 #include "storage/ipld/impl/ipld_link_impl.hpp"
 #include "storage/ipld/impl/ipld_node_encoder_pb.hpp"
-#include "storage/ipld/ipld_block_common.hpp"
 #include "storage/ipld/ipld_node.hpp"
 
 namespace fc::storage::ipld {
-  class IPLDNodeImpl : public IPLDNode,
-                       IPLDBlockCommon<CID::Version::V0,
-                                       HashType::sha256,
-                                       ContentType::DAG_PB> {
+  class IPLDNodeImpl : public IPLDNode {
    public:
+    const CID &getCID() const override;
+
+    const Buffer &getRawBytes() const override;
+
     size_t size() const override;
 
     void assign(common::Buffer input) override;
@@ -42,20 +42,36 @@ namespace fc::storage::ipld {
     std::vector<std::reference_wrapper<const IPLDLink>> getLinks()
         const override;
 
+    Buffer serialize() const override;
+
     static std::shared_ptr<IPLDNode> createFromString(
         const std::string &content);
 
     static outcome::result<std::shared_ptr<IPLDNode>> createFromRawBytes(
         gsl::span<const uint8_t> input);
 
+    const IPLDBlock &getIPLDBlock() const;
+
    private:
     common::Buffer content_;
     std::map<std::string, IPLDLinkImpl> links_;
     IPLDNodeEncoderPB pb_node_codec_;
     size_t child_nodes_size_{};
-
-    outcome::result<std::vector<uint8_t>> getBlockContent() const override;
+    mutable boost::optional<IPLDBlock> ipld_block_;
   };
+
+  template <>
+  inline IPLDType IPLDBlock::getType<IPLDNodeImpl>() {
+    return {IPLDType::Version::V0,
+            IPLDType::Content::DAG_PB,
+            IPLDType::Hash::sha256};
+  }
+
+  template <>
+  inline common::Buffer IPLDBlock::serialize<IPLDNodeImpl>(
+      const IPLDNodeImpl &entity) {
+    return entity.serialize();
+  }
 }  // namespace fc::storage::ipld
 
 #endif

core/storage/ipld/ipld_block.hpp

@@ -8,32 +8,76 @@
 
 #include <vector>
 
+#include "codec/cbor/cbor.hpp"
 #include "common/buffer.hpp"
+#include "crypto/hasher/hasher.hpp"
 #include "primitives/cid/cid.hpp"
 
 namespace fc::storage::ipld {
+
+  /**
+   * @struct IPLD block CID and content properties
+   */
+  struct IPLDType {
+    using Version = CID::Version;
+    using Content = libp2p::multi::MulticodecType::Code;
+    using Hash = libp2p::multi::HashType;
+
+    Version cid_version;
+    Content content_type;
+    Hash hash_type;
+  };
+
   /**
-   * @class Interface for various data structure, linked with CID
+   * @struct IPLD block: CID and serialized bytes
    */
-  class IPLDBlock {
-   public:
+  struct IPLDBlock {
+    CID cid;
+    common::Buffer bytes;
+
     /**
-     * @brief Destructor
+     * @brief Create IPLD block from supported entity
+     * @tparam T - type of entity
+     * @param entity - source object
+     * @return constructed block
      */
-    virtual ~IPLDBlock() = default;
+    template <class T>
+    static IPLDBlock create(const T &entity) {
+      IPLDType params = IPLDBlock::getType<T>();
+      common::Buffer bytes = IPLDBlock::serialize(entity);
+      auto multihash = crypto::Hasher::calculate(params.hash_type, bytes);
+      return IPLDBlock{CID{params.cid_version, params.content_type, multihash},
+                       bytes};
+    }
 
     /**
-     * @brief Get CID of the data structure
-     * @return IPLD identificator
+     * @brief Get default IPLD block params:
+     * @note This method should be specialized for each IPLD entity,
+     *       which uses another types
+     * @tparam T - type of IPLD entity
+     * @return IPLD block params
      */
-    virtual const CID &getCID() const = 0;
+    template <class T>
+    static IPLDType getType() {
+      return {IPLDType::Version::V1,
+              IPLDType::Content::DAG_CBOR,
+              IPLDType::Hash::blake2b_256};
+    }
 
     /**
-     * @brief Get data structure bytes from cache or generate new
-     * @return Serialized value
+     * @brief CBOR serialize IPLD entity
+     * @note This method should be specialized for each IPLD entity,
+     *       which uses another serialization codec
+     * @tparam T - type of the entity
+     * @param entity - object to serialize
+     * @return serialized bytes
      */
-    virtual const common::Buffer &getRawBytes() const = 0;
-
+    template <class T>
+    static common::Buffer serialize(const T &entity) {
+      auto data = codec::cbor::encode(entity);
+      BOOST_ASSERT(data.has_value());
+      return common::Buffer{std::move(data.value())};
+    }
   };
 }  // namespace fc::storage::ipld