update block validator (#547)

Signed-off-by: turuslan <[email protected]>

Author: turuslan

core/CMakeLists.txt

@@ -18,7 +18,6 @@ add_subdirectory(markets)
 add_subdirectory(miner)
 add_subdirectory(node)
 add_subdirectory(paych)
-add_subdirectory(power)
 add_subdirectory(primitives)
 add_subdirectory(proofs)
 add_subdirectory(remote_worker)

core/api/full_node/make.cpp

@@ -11,6 +11,8 @@
 
 #include "adt/stop.hpp"
 #include "api/version.hpp"
+#include "blockchain/block_validator/eligible.hpp"
+#include "blockchain/block_validator/win_sectors.hpp"
 #include "blockchain/production/block_producer.hpp"
 #include "cbor_blake/ipld_version.hpp"
 #include "common/logger.hpp"
@@ -21,6 +23,7 @@
 #include "markets/retrieval/protocols/retrieval_protocol.hpp"
 #include "node/node_version.hpp"
 #include "node/pubsub_gate.hpp"
+#include "primitives/block/rand.hpp"
 #include "primitives/tipset/chain.hpp"
 #include "proofs/impl/proof_engine_impl.hpp"
 #include "storage/car/car.hpp"
@@ -60,10 +63,6 @@
 namespace fc::api {
   using connection_t = boost::signals2::connection;
   using InterpreterResult = vm::interpreter::Result;
-  using common::Logger;
-  using crypto::randomness::DomainSeparationTag;
-  using crypto::signature::BlsSignature;
-  using libp2p::peer::PeerId;
   using markets::retrieval::DealProposalParams;
   using markets::retrieval::QueryResponse;
   using node::kNodeVersion;
@@ -95,14 +94,6 @@ namespace fc::api {
   using vm::toolchain::Toolchain;
   using vm::version::getNetworkVersion;
 
-  // TODO (turuslan): reuse for block validation
-  inline bool minerHasMinPower(const StoragePower &claim_qa,
-                               size_t min_power_miners) {
-    return min_power_miners < kConsensusMinerMinMiners
-               ? !claim_qa.is_zero()
-               : claim_qa > kConsensusMinerMinPower;
-  }
-
   void beaconEntriesForBlock(const DrandSchedule &schedule,
                              Beaconizer &beaconizer,
                              ChainEpoch epoch,
@@ -168,53 +159,6 @@ namespace fc::api {
     }
   };
 
-  // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-  outcome::result<std::vector<SectorInfo>> getSectorsForWinningPoSt(
-      NetworkVersion network,
-      const Address &miner,
-      const MinerActorStatePtr &state,
-      const Randomness &post_rand,
-      const IpldPtr &ipld) {
-    std::vector<SectorInfo> sectors;
-    RleBitset sectors_bitset;
-    OUTCOME_TRY(deadlines, state->deadlines.get());
-    for (const auto &deadline_cid : deadlines.due) {
-      OUTCOME_TRY(deadline, deadline_cid.get());
-      OUTCOME_TRY(deadline->partitions.visit([&](auto, auto &part) {
-        for (auto sector : part->sectors) {
-          if (network >= NetworkVersion::kVersion7) {
-            if (part->terminated.has(sector) || part->unproven.has(sector)) {
-              continue;
-            }
-          }
-          if (!part->faults.has(sector)) {
-            sectors_bitset.insert(sector);
-          }
-        }
-        return outcome::success();
-      }));
-    }
-    if (!sectors_bitset.empty()) {
-      OUTCOME_TRY(miner_info, state->getInfo());
-      OUTCOME_TRY(
-          win_type,
-          getRegisteredWinningPoStProof(miner_info->window_post_proof_type));
-      static auto proofs{std::make_shared<proofs::ProofEngineImpl>()};
-      OUTCOME_TRY(
-          indices,
-          proofs->generateWinningPoStSectorChallenge(
-              win_type, miner.getId(), post_rand, sectors_bitset.size()));
-      std::vector<uint64_t> sector_ids{sectors_bitset.begin(),
-                                       sectors_bitset.end()};
-      for (auto &i : indices) {
-        OUTCOME_TRY(sector, state->sectors.sectors.get(sector_ids[i]));
-        sectors.push_back(
-            {sector.seal_proof, sector.sector, sector.sealed_cid});
-      }
-    }
-    return sectors;
-  }
-
   // NOLINTNEXTLINE(hicpp-function-size,readability-function-cognitive-complexity,readability-function-size,google-readability-function-size)
   std::shared_ptr<FullNodeApi> makeImpl(
       std::shared_ptr<FullNodeApi> api,
@@ -635,19 +579,19 @@ namespace fc::api {
                 }
                 OUTCOME_CB(auto miner_state,
                            getCbor<MinerActorStatePtr>(lookback, actor->head));
-                OUTCOME_CB(auto seed, codec::cbor::encode(miner));
-                auto post_rand{crypto::randomness::drawRandomness(
-                    info.beacon().data,
-                    DomainSeparationTag::WinningPoStChallengeSeed,
+                const BlockRand rand{
+                    miner,
                     epoch,
-                    seed)};
+                    info.beacons,
+                    info.prev_beacon,
+                    *context.tipset,
+                };
                 OUTCOME_CB(info.sectors,
                            getSectorsForWinningPoSt(
                                getNetworkVersion(context.tipset->epoch()),
                                miner,
                                miner_state,
-                               post_rand,
-                               lookback));
+                               rand.win));
                 if (info.sectors.empty()) {
                   return cb(boost::none);
                 }
@@ -658,8 +602,11 @@ namespace fc::api {
                 OUTCOME_CB(auto miner_info, miner_state->getInfo());
                 OUTCOME_CB(info.worker, context.accountKey(miner_info->worker));
                 info.sector_size = miner_info->sector_size;
-                info.has_min_power = minerHasMinPower(
-                    claim->qa_power, power_state->num_miners_meeting_min_power);
+                OUTCOME_CB(info.has_min_power,
+                           minerEligibleToMine(miner,
+                                               lookback.tipset,
+                                               context.tipset,
+                                               context.state_tree));
                 cb(std::move(info));
               });
         };

core/blockchain/block_validator/CMakeLists.txt

@@ -4,16 +4,14 @@
 #
 
 add_library(block_validator
-    impl/block_validator_impl.cpp
-    impl/syntax_rules.cpp
-    impl/consensus_rules.cpp
+    validator.cpp
     )
 target_link_libraries(block_validator
     bls_provider
     outcome
     address
     clock
     interpreter
+    map_prefix
     tipset
-    power_table
     )

core/blockchain/block_validator/block_validator.hpp

@@ -0,0 +1,79 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "cbor_blake/ipld_version.hpp"
+#include "primitives/tipset/tipset.hpp"
+#include "vm/actor/builtin/states/miner/miner_actor_state.hpp"
+#include "vm/actor/builtin/states/storage_power/storage_power_actor_state.hpp"
+#include "vm/actor/builtin/types/storage_power/policy.hpp"
+#include "vm/state/impl/state_tree_impl.hpp"
+
+namespace fc::blockchain::block_validator {
+  using primitives::address::Address;
+  using primitives::tipset::TipsetCPtr;
+  using vm::actor::kStoragePowerAddress;
+  using vm::actor::builtin::states::Claim;
+  using vm::actor::builtin::states::MinerActorStatePtr;
+  using vm::actor::builtin::states::PowerActorStatePtr;
+  using vm::state::StateTreeImpl;
+
+  inline bool minerHasMinPower(const PowerActorStatePtr &state,
+                               const Claim &claim) {
+    const auto &power{state.actor_version == ActorVersion::kVersion0
+                          ? claim.qa_power
+                          : claim.raw_power};
+    return state->num_miners_meeting_min_power < kConsensusMinerMinMiners
+               ? !power.is_zero()
+               : power > vm::actor::builtin::types::storage_power::
+                         kConsensusMinerMinPower;
+  }
+
+  inline outcome::result<bool> minerEligibleToMine(const Address &miner,
+                                                   const TipsetCPtr &lookback,
+                                                   const TipsetCPtr &parent,
+                                                   StateTreeImpl &parent_tree) {
+    StateTreeImpl lookback_tree{
+        withVersion(parent_tree.getStore(), lookback->height()),
+        lookback->getParentStateRoot()};
+    OUTCOME_TRY(lookback_power_actor, lookback_tree.get(kStoragePowerAddress));
+    OUTCOME_TRY(lookback_power,
+                getCbor<PowerActorStatePtr>(lookback_tree.getStore(),
+                                            lookback_power_actor.head));
+    OUTCOME_TRY(lookback_claim, lookback_power->getClaim(miner));
+    if (!minerHasMinPower(lookback_power, *lookback_claim)) {
+      return false;
+    }
+    if (vm::version::getNetworkVersion(parent->height())
+        <= vm::version::NetworkVersion::kVersion3) {
+      return true;
+    }
+    OUTCOME_TRY(parent_power_actor, parent_tree.get(kStoragePowerAddress));
+    OUTCOME_TRY(parent_power,
+                getCbor<PowerActorStatePtr>(parent_tree.getStore(),
+                                            parent_power_actor.head));
+    OUTCOME_TRY(parent_claim, parent_power->tryGetClaim(miner));
+    if (!parent_claim || (**parent_claim).qa_power <= 0) {
+      return false;
+    }
+    OUTCOME_TRY(parent_miner_actor, parent_tree.get(miner));
+    OUTCOME_TRY(parent_miner,
+                getCbor<MinerActorStatePtr>(parent_tree.getStore(),
+                                            parent_miner_actor.head));
+    if (!parent_miner->fee_debt.is_zero()) {
+      return false;
+    }
+    OUTCOME_TRY(parent_miner_info, parent_miner->getInfo());
+    if (parent->height() <= parent_miner_info->consensus_fault_elapsed) {
+      return false;
+    }
+    return true;
+  }
+}  // namespace fc::blockchain::block_validator
+
+namespace fc {
+  using blockchain::block_validator::minerEligibleToMine;
+}  // namespace fc