refactor chain randomness (#109)

* implement feature

Signed-off-by: Yura Zarudniy <[email protected]>

* refactor chainstore

Signed-off-by: Yura Zarudniy <[email protected]>

* try fix under ref

Signed-off-by: Yura Zarudniy <[email protected]>

* fix review issues

Signed-off-by: Yura Zarudniy <[email protected]>

Author: Yura Zarudniy

core/crypto/randomness/CMakeLists.txt

@@ -10,3 +10,13 @@ target_link_libraries(randomness_provider
     buffer
     p2p::p2p_sha
     )
+
+add_library(chain_randomness_provider
+    impl/chain_randomness_provider_impl.cpp
+    )
+target_link_libraries(chain_randomness_provider
+    Boost::boost
+    blob
+    buffer
+    p2p::p2p_sha
+    )

core/crypto/randomness/chain_randomness_provider.hpp

@@ -0,0 +1,28 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_CHAIN_RANDOMNESS_PROVIDER_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_CHAIN_RANDOMNESS_PROVIDER_HPP
+
+#include "crypto/randomness/randomness_types.hpp"
+#include "primitives/cid/cid.hpp"
+
+namespace fc::crypto::randomness {
+
+  /**
+   * @class ChainRandomnessProvider provides method for calculating chain
+   * randomness
+   */
+  class ChainRandomnessProvider {
+   public:
+    virtual ~ChainRandomnessProvider() = default;
+
+    /** @brief calculate randomness */
+    virtual outcome::result<Randomness> sampleRandomness(
+        const std::vector<CID> &block_cids, uint64_t round) = 0;
+  };
+}  // namespace fc::crypto::randomness
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_CHAIN_RANDOMNESS_PROVIDER_HPP

core/crypto/randomness/impl/chain_randomness_provider_impl.cpp

@@ -0,0 +1,80 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/randomness/impl/chain_randomness_provider_impl.hpp"
+
+#include <boost/assert.hpp>
+#include <libp2p/crypto/sha/sha256.hpp>
+#include "common/le_encoder.hpp"
+#include "primitives/ticket/ticket.hpp"
+#include "primitives/tipset/tipset_key.hpp"
+#include "storage/chain/chain_store.hpp"
+
+namespace fc::crypto::randomness {
+
+  using crypto::randomness::Randomness;
+  using primitives::ticket::Ticket;
+  using primitives::tipset::TipsetKey;
+
+  namespace {
+    /**
+     * @brief ChainStore needs its own randomnes calculation function
+     * @return randomness value
+     */
+    crypto::randomness::Randomness drawRandomness(const Ticket &ticket,
+                                                  uint64_t round) {
+      common::Buffer buffer{};
+      const size_t bytes_required = sizeof(round) + ticket.bytes.size();
+      buffer.reserve(bytes_required);
+
+      buffer.put(ticket.bytes);
+      common::encodeLebInteger(round, buffer);
+
+      auto hash = libp2p::crypto::sha256(buffer);
+
+      return crypto::randomness::Randomness(hash);
+    }
+  }  // namespace
+
+  ChainRandomnessProviderImpl::ChainRandomnessProviderImpl(
+      std::shared_ptr<storage::blockchain::ChainStore> chain_store)
+      : chain_store_(std::move(chain_store)) {
+    BOOST_ASSERT_MSG(chain_store_ != nullptr,
+                     "chain_store argument == nullptr");
+  }
+
+  outcome::result<Randomness> ChainRandomnessProviderImpl::sampleRandomness(
+      const std::vector<CID> &block_cids, uint64_t round) {
+    std::reference_wrapper<const std::vector<CID>> cids{block_cids};
+
+    while (true) {
+      OUTCOME_TRY(tipset, chain_store_->loadTipset(TipsetKey{cids.get()}));
+      OUTCOME_TRY(min_ticket_block, tipset.getMinTicketBlock());
+
+      if (tipset.height <= round) {
+        BOOST_ASSERT_MSG(min_ticket_block.get().ticket.has_value(),
+                         "min ticket block has no value, internal error");
+
+        return drawRandomness(*min_ticket_block.get().ticket, round);
+      }
+
+      // special case for lookback behind genesis block
+      if (min_ticket_block.get().height == 0) {
+        // round is negative
+        auto &&negative_hash =
+            drawRandomness(*min_ticket_block.get().ticket, round - 1);
+        // for negative lookbacks, just use the hash of the positive ticket hash
+        // value
+        auto &&positive_hash = libp2p::crypto::sha256(negative_hash);
+        return Randomness{positive_hash};
+      }
+
+      // TODO (yuraz) I know it's very ugly, and needs to be refactored
+      // I translated it directly from go to C++
+      cids = min_ticket_block.get().parents;
+    }
+  }
+
+}  // namespace fc::crypto::randomness

core/crypto/randomness/impl/chain_randomness_provider_impl.hpp

@@ -0,0 +1,28 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_IMPL_CHAIN_RANDOMNESS_PROVIDER_IMPL_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_IMPL_CHAIN_RANDOMNESS_PROVIDER_IMPL_HPP
+
+#include "crypto/randomness/chain_randomness_provider.hpp"
+#include "storage/chain/chain_store.hpp"
+
+namespace fc::crypto::randomness {
+  class ChainRandomnessProviderImpl : public ChainRandomnessProvider {
+   public:
+    ~ChainRandomnessProviderImpl() override = default;
+
+    explicit ChainRandomnessProviderImpl(
+        std::shared_ptr<storage::blockchain::ChainStore> chain_store);
+
+    outcome::result<Randomness> sampleRandomness(
+        const std::vector<CID> &block_cids, uint64_t round) override;
+
+   private:
+    std::shared_ptr<storage::blockchain::ChainStore> chain_store_;
+  };
+}  // namespace fc::crypto::randomness
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_IMPL_CHAIN_RANDOMNESS_PROVIDER_IMPL_HPP

core/storage/chain/CMakeLists.txt

@@ -2,9 +2,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 add_library(chain_store
-    chain_store.cpp
+    impl/chain_store_impl.cpp
     )
 target_link_libraries(chain_store
+    chain_randomness_provider
     datastore_key
     ipfs_blockservice
     logger

core/storage/chain/chain_store.hpp

@@ -6,17 +6,8 @@
 #ifndef CPP_FILECOIN_CORE_STORAGE_CHAIN_CHAIN_STORE_HPP
 #define CPP_FILECOIN_CORE_STORAGE_CHAIN_CHAIN_STORE_HPP
 
-#include <map>
-
-#include "blockchain/block_validator.hpp"
-#include "blockchain/weight_calculator.hpp"
-#include "common/logger.hpp"
-#include "common/outcome.hpp"
-#include "crypto/randomness/randomness_types.hpp"
-#include "primitives/cid/cid.hpp"
+#include "primitives/block/block.hpp"
 #include "primitives/tipset/tipset.hpp"
-#include "storage/chain/chain_data_store.hpp"
-#include "storage/ipfs/impl/ipfs_block_service.hpp"
 
 namespace fc::storage::blockchain {
 
@@ -33,90 +24,36 @@ namespace fc::storage::blockchain {
     primitives::tipset::Tipset value;
   };
 
-  /**
-   * @struct MmCids is a struct for using in mmCache cache
-   */
-  struct MmCids {
-    std::vector<CID> bls;
-    std::vector<CID> secpk;
-  };
-
-  enum class ChainStoreError : int { NO_MIN_TICKET_BLOCK = 1 };
-
   /**
    * @class ChainStore keeps track of blocks
    */
   class ChainStore {
    public:
-    using BlockValidator = ::fc::blockchain::block_validator::BlockValidator;
+    using BlockHeader = primitives::block::BlockHeader;
+    using ChainRandomnessProvider = crypto::randomness::ChainRandomnessProvider;
+    using Randomness = crypto::randomness::Randomness;
     using Tipset = primitives::tipset::Tipset;
     using TipsetKey = primitives::tipset::TipsetKey;
-    using Randomness = crypto::randomness::Randomness;
-    using BlockHeader = primitives::block::BlockHeader;
-    using WeightCalculator = ::fc::blockchain::weight::WeightCalculator;
 
-    /* @brief creates new ChainStore instance */
-    static outcome::result<std::shared_ptr<ChainStore>> create(
-        std::shared_ptr<ipfs::IpfsBlockService> block_service,
-        std::shared_ptr<ChainDataStore> data_store,
-        std::shared_ptr<BlockValidator> block_validator,
-        std::shared_ptr<WeightCalculator> weight_calculator);
-
-    /** @brief stores head tipset */
-    outcome::result<void> writeHead(const Tipset &tipset);
-
-    /** @brief loads data from block storage and initializes storage */
-    outcome::result<void> load();
+    virtual ~ChainStore() = default;
 
     /**
      * @brief loads tipset from store
      * @param key tipset key
      */
-    outcome::result<Tipset> loadTipset(const TipsetKey &key);
-
-    // TODO(yuraz): FIL-151 add notifications
-    // TODO(yuraz): FIL-151 implement items caching to avoid refetching them
+    virtual outcome::result<Tipset> loadTipset(const TipsetKey &key) = 0;
 
-    /** @brief draws randomness */
-    outcome::result<Randomness> sampleRandomness(const std::vector<CID> &blks,
-                                                 uint64_t round);
-
-    /** @brief finds block by its cid */
-    outcome::result<BlockHeader> getBlock(const CID &cid) const;
+    /** @brief creates chain randomness provider */
+    virtual std::shared_ptr<ChainRandomnessProvider>
+    createRandomnessProvider() = 0;
 
     /** @brief adds block to store */
-    outcome::result<void> addBlock(const BlockHeader &block);
-
-   private:
-    ChainStore(std::shared_ptr<ipfs::IpfsBlockService> block_service,
-               std::shared_ptr<ChainDataStore> data_store,
-               std::shared_ptr<BlockValidator> block_validator,
-               std::shared_ptr<WeightCalculator> weight_calculator);
-
-    ChainStore(ChainStore &&other) = default;
-
-    outcome::result<void> takeHeaviestTipset(const Tipset &tipset);
-
-    outcome::result<void> persistBlockHeaders(
-        const std::vector<std::reference_wrapper<const BlockHeader>>
-            &block_headers);
-
-    outcome::result<Tipset> expandTipset(const BlockHeader &block_header);
+    virtual outcome::result<void> addBlock(const BlockHeader &block) = 0;
 
-    outcome::result<void> updateHeavierTipset(const Tipset &tipset);
-
-    std::shared_ptr<ipfs::IpfsBlockService> block_service_;
-    std::shared_ptr<ChainDataStore> data_store_;
-    std::shared_ptr<BlockValidator> block_validator_;
-    std::shared_ptr<WeightCalculator> weight_calculator_;
-
-    boost::optional<Tipset> heaviest_tipset_;
-    std::map<uint64_t, std::vector<CID>> tipsets_;
-
-    common::Logger logger_;
+    /** @brief finds block by its cid */
+    virtual outcome::result<BlockHeader> getBlock(const CID &cid) const = 0;
   };
-}  // namespace fc::storage::blockchain
 
-OUTCOME_HPP_DECLARE_ERROR(fc::storage::blockchain, ChainStoreError);
+}  // namespace fc::storage::blockchain
 
 #endif  // CPP_FILECOIN_CORE_STORAGE_CHAIN_CHAIN_STORE_HPP