Miner actor submit window post v2 (#467)

Signed-off-by: Mikhail Tagirov <[email protected]>

Author: Mikhail Tagirov

core/crypto/randomness/randomness_types.hpp

@@ -15,6 +15,8 @@ namespace fc::crypto::randomness {
   /// @brief randomness value type
   using Randomness = common::Hash256;
 
+  constexpr size_t kRandomnessLength = 32;
+
   /// @brief domain separation tag enum
   enum class DomainSeparationTag : uint64_t {
     TicketProduction = 1,

core/vm/actor/builtin/v2/miner/miner_actor.cpp

@@ -6,17 +6,19 @@
 #include "vm/actor/builtin/v2/miner/miner_actor.hpp"
 
 #include "vm/actor/builtin/states/miner/miner_actor_state.hpp"
-#include "vm/actor/builtin/types/miner/policy.hpp"
-#include "vm/actor/builtin/v2/account/account_actor.hpp"
-#include "vm/actor/builtin/v2/storage_power/storage_power_actor.hpp"
+#include "vm/actor/builtin/types/miner/monies.hpp"
 #include "vm/toolchain/toolchain.hpp"
 
 namespace fc::vm::actor::builtin::v2::miner {
+  using crypto::randomness::DomainSeparationTag;
+  using crypto::randomness::kRandomnessLength;
+  using crypto::randomness::Randomness;
   using primitives::ChainEpoch;
   using primitives::RleBitset;
   using states::makeEmptyMinerState;
   using states::MinerActorStatePtr;
   using toolchain::Toolchain;
+  using types::Universal;
   using namespace types::miner;
 
   ACTOR_METHOD_IMPL(Construct) {
@@ -108,6 +110,122 @@ namespace fc::vm::actor::builtin::v2::miner {
     return outcome::success();
   }
 
+  ACTOR_METHOD_IMPL(SubmitWindowedPoSt) {
+    const auto current_epoch = runtime.getCurrentEpoch();
+    const auto network_version = runtime.getNetworkVersion();
+
+    OUTCOME_TRY(
+        runtime.validateArgument(params.deadline < kWPoStPeriodDeadlines));
+
+    OUTCOME_TRY(runtime.validateArgument(params.chain_commit_rand.size()
+                                         <= kRandomnessLength));
+
+    RleBitset partition_indexes;
+    if (network_version >= NetworkVersion::kVersion7) {
+      for (const auto &partition : params.partitions) {
+        partition_indexes.insert(partition.index);
+      }
+    }
+
+    const auto utils = Toolchain::createMinerUtils(runtime);
+
+    OUTCOME_TRY(state, runtime.getActorState<MinerActorStatePtr>());
+
+    OUTCOME_TRY(miner_info, state->getInfo());
+
+    auto callers = miner_info->control;
+    callers.emplace_back(miner_info->owner);
+    callers.emplace_back(miner_info->worker);
+    OUTCOME_TRY(runtime.validateImmediateCallerIs(callers));
+
+    OUTCOME_TRY(runtime.validateArgument(params.proofs.size() == 1));
+    OUTCOME_TRY(
+        runtime.validateArgument(params.proofs[0].registered_proof
+                                 == miner_info->window_post_proof_type));
+
+    const auto submission_partition_limit = utils->loadPartitionsSectorsMax(
+        miner_info->window_post_partition_sectors);
+    OUTCOME_TRY(runtime.validateArgument(params.partitions.size()
+                                         <= submission_partition_limit));
+
+    const auto deadline_info = state->deadlineInfo(current_epoch);
+
+    if (!deadline_info.isOpen()) {
+      ABORT(VMExitCode::kErrIllegalState);
+    }
+
+    OUTCOME_TRY(
+        runtime.validateArgument(params.deadline == deadline_info.index));
+
+    OUTCOME_TRY(runtime.validateArgument(params.chain_commit_epoch
+                                         >= deadline_info.challenge));
+
+    OUTCOME_TRY(
+        runtime.validateArgument(params.chain_commit_epoch < current_epoch));
+
+    OUTCOME_TRY(
+        randomness,
+        runtime.getRandomnessFromTickets(DomainSeparationTag::PoStChainCommit,
+                                         params.chain_commit_epoch,
+                                         {}));
+    OUTCOME_TRY(
+        runtime.validateArgument(randomness == params.chain_commit_rand));
+
+    REQUIRE_NO_ERROR_A(
+        sectors, state->sectors.loadSectors(), VMExitCode::kErrIllegalState);
+
+    REQUIRE_NO_ERROR_A(
+        deadlines, state->deadlines.get(), VMExitCode::kErrIllegalState);
+
+    REQUIRE_NO_ERROR_A(deadline,
+                       deadlines.loadDeadline(params.deadline),
+                       VMExitCode::kErrIllegalState);
+
+    if (network_version >= NetworkVersion::kVersion7) {
+      const auto already_proven =
+          deadline->partitions_posted.intersect(partition_indexes);
+      OUTCOME_TRY(runtime.validateArgument(already_proven.empty()));
+    }
+
+    const auto fault_expiration = deadline_info.last() + kFaultMaxAge;
+    REQUIRE_NO_ERROR_A(post_result,
+                       deadline->recordProvenSectors(runtime,
+                                                     sectors,
+                                                     miner_info->sector_size,
+                                                     deadline_info.quant(),
+                                                     fault_expiration,
+                                                     params.partitions),
+                       VMExitCode::kErrIllegalState);
+
+    REQUIRE_NO_ERROR_A(
+        sector_infos,
+        sectors.loadForProof(post_result.sectors, post_result.ignored_sectors),
+        VMExitCode::kErrIllegalState);
+
+    OUTCOME_TRY(runtime.validateArgument(!sector_infos.empty()));
+
+    OUTCOME_TRY(utils->verifyWindowedPost(
+        deadline_info.challenge, sector_infos, params.proofs));
+
+    REQUIRE_NO_ERROR(deadlines.updateDeadline(params.deadline, deadline),
+                     VMExitCode::kErrIllegalState);
+
+    REQUIRE_NO_ERROR(state->deadlines.set(deadlines),
+                     VMExitCode::kErrIllegalState);
+
+    OUTCOME_TRY(runtime.commitState(state));
+
+    OUTCOME_TRY(utils->requestUpdatePower(post_result.power_delta));
+
+    OUTCOME_TRYA(state, runtime.getActorState<MinerActorStatePtr>());
+
+    OUTCOME_TRY(balance, runtime.getCurrentBalance());
+    REQUIRE_NO_ERROR(state->checkBalanceInvariants(balance),
+                     VMExitCode::kErrIllegalState);
+
+    return outcome::success();
+  }
+
   ACTOR_METHOD_IMPL(ApplyRewards) {
     // TODO (a.chernyshov) FIL-310 - implement
     return VMExitCode::kNotImplemented;

core/vm/actor/builtin/v2/miner/miner_actor.hpp

@@ -26,8 +26,13 @@ namespace fc::vm::actor::builtin::v2::miner {
 
   using ChangePeerId = v0::miner::ChangePeerId;
 
+  struct SubmitWindowedPoSt : ActorMethodBase<5> {
+    using Params = v0::miner::SubmitWindowedPoSt::Params;
+
+    ACTOR_METHOD_DECL();
+  };
+
   // TODO implement
-  using SubmitWindowedPoSt = v0::miner::SubmitWindowedPoSt;
   using PreCommitSector = v0::miner::PreCommitSector;
   using ProveCommitSector = v0::miner::ProveCommitSector;
   using ExtendSectorExpiration = v0::miner::ExtendSectorExpiration;

core/vm/actor/impl/invoker_impl.cpp

@@ -85,6 +85,8 @@ namespace fc::vm::actor {
         builtin::v2::miner::ChangePeerId::Number);
     ready_miner_actor_methods_v2.insert(
         builtin::v2::miner::ChangeWorkerAddress::Number);
+    ready_miner_actor_methods_v2.insert(
+        builtin::v2::miner::SubmitWindowedPoSt::Number);
   }
 
   outcome::result<InvocationOutput> InvokerImpl::invoke(