Fix Activation (#583)

* Fix Activation

Signed-off-by: ortyomka <iurin.art@gmail.com>

* Fix graphsync segfault
Use getMaxProveCommitDuration instead of const

Signed-off-by: ortyomka <iurin.art@gmail.com>

Author: ortyomka

core/miner/impl/miner_impl.cpp

@@ -85,8 +85,9 @@ namespace fc::miner {
     std::shared_ptr<PreCommitPolicy> precommit_policy =
         std::make_shared<BasicPreCommitPolicy>(
             api,
-            deadline_info.period_start % kWPoStProvingPeriod,
-            kMaxSectorExpirationExtension - 2 * kWPoStProvingPeriod);
+            2 * kWPoStProvingPeriod,
+            std::chrono::seconds(kMaxSectorExpirationExtension
+                                 * kEpochDurationSeconds));
     std::shared_ptr<FeeConfig> fee_config = std::make_shared<FeeConfig>();
     fee_config->max_precommit_batch_gas_fee.base = {
         0};  // TODO(ortyomka): config loading;

core/miner/storage_fsm/impl/basic_precommit_policy.cpp

@@ -7,6 +7,7 @@
 
 namespace fc::mining {
   using vm::actor::builtin::types::miner::kMaxSectorExpirationExtension;
+  using vm::actor::builtin::types::miner::kMinSectorExpiration;
   using vm::actor::builtin::types::miner::kWPoStProvingPeriod;
 
   outcome::result<ChainEpoch> BasicPreCommitPolicy::expiration(
@@ -39,17 +40,34 @@ namespace fc::mining {
       end = epoch + duration_;
     }
 
-    *end += kWPoStProvingPeriod - (*end % kWPoStProvingPeriod)
-            + proving_boundary_ - 1;
+    const auto min_exp = epoch + kMinSectorExpiration + kWPoStProvingPeriod;
+
+    if (end < min_exp) {
+      end = min_exp;
+    }
 
     return *end;
   }
 
-  BasicPreCommitPolicy::BasicPreCommitPolicy(std::shared_ptr<FullNodeApi> api,
-                                             ChainEpoch proving_boundary,
-                                             ChainEpoch duration)
+  BasicPreCommitPolicy::BasicPreCommitPolicy(
+      std::shared_ptr<FullNodeApi> api,
+      ChainEpoch proving_boundary,
+      std::chrono::seconds sector_lifetime)
       : api_(std::move(api)),
         proving_boundary_(proving_boundary),
-        duration_(duration),
-        logger_(common::createLogger("basic pre commit policy")) {}
+        logger_(common::createLogger("basic pre commit policy")) {
+    ChainEpoch sector_lifetime_ =
+        std::ceil(sector_lifetime.count() / double(kEpochDurationSeconds));
+    if (sector_lifetime_ == 0) {
+      sector_lifetime_ = kMaxSectorExpirationExtension;
+    }
+
+    if (sector_lifetime_ < kMinSectorExpiration) {
+      duration_ = kMinSectorExpiration;
+    } else if (sector_lifetime_ > kMaxSectorExpirationExtension) {
+      duration_ = kMaxSectorExpirationExtension;
+    } else {
+      duration_ = sector_lifetime_ - proving_boundary_;
+    }
+  }
 }  // namespace fc::mining

core/miner/storage_fsm/impl/basic_precommit_policy.hpp

@@ -16,7 +16,7 @@ namespace fc::mining {
    public:
     BasicPreCommitPolicy(std::shared_ptr<FullNodeApi> api,
                          ChainEpoch proving_boundary,
-                         ChainEpoch duration);
+                         std::chrono::seconds sector_lifetime);
 
     outcome::result<ChainEpoch> expiration(
         gsl::span<const types::Piece> pieces) override;

core/miner/storage_fsm/impl/precommit_batcher_impl.hpp

@@ -48,7 +48,7 @@ namespace fc::mining {
 
       ~PreCommitEntry() = default;
 
-      PreCommitEntry &operator=(const PreCommitEntry &other)  = default;
+      PreCommitEntry &operator=(const PreCommitEntry &other) noexcept = default;
       PreCommitEntry &operator=(PreCommitEntry &&) noexcept = default;
 
       TokenAmount deposit{};

core/miner/storage_fsm/impl/sealing_impl.cpp

@@ -45,7 +45,11 @@ namespace fc::mining {
   using vm::actor::builtin::types::market::deal_info_manager::
       DealInfoManagerImpl;
   using vm::actor::builtin::types::miner::kChainFinality;
+  using vm::actor::builtin::types::miner::kMaxPreCommitRandomnessLookback;
+  using vm::actor::builtin::types::miner::kMaxProveCommitDuration;
+  using vm::actor::builtin::types::miner::kMaxSectorExpirationExtension;
   using vm::actor::builtin::types::miner::kMinSectorExpiration;
+  using vm::actor::builtin::types::miner::kPreCommitChallengeDelay;
   using vm::actor::builtin::v0::miner::PreCommitSector;
   using vm::actor::builtin::v0::miner::ProveCommitSector;
 
@@ -1137,14 +1141,22 @@ namespace fc::mining {
     OUTCOME_TRY(seal_duration,
                 checks::getMaxProveCommitDuration(network, info));
     OUTCOME_TRY(policy_expiration, policy_->expiration(info->pieces));
-    const ChainEpoch static_expiration =
-        head->epoch() + seal_duration + kMinSectorExpiration + kChainFinality
-        + gsl::narrow<ChainEpoch>(kEpochsInDay);
-    const auto expiration =
-        std::min<ChainEpoch>(policy_expiration, static_expiration);
+    const auto min_expiration = info->ticket_epoch
+                                + kMaxPreCommitRandomnessLookback
+                                + seal_duration + kMinSectorExpiration;
+
+    if (policy_expiration < min_expiration) {
+      policy_expiration = min_expiration;
+    }
+
+    const auto max_expiration = head->epoch() + kPreCommitChallengeDelay
+                                + kMaxSectorExpirationExtension;
+    if (policy_expiration > max_expiration) {
+      policy_expiration = max_expiration;
+    }
 
     SectorPreCommitInfo params;
-    params.expiration = expiration;
+    params.expiration = policy_expiration;
     params.sector = info->sector_number;
     params.registered_proof = info->sector_type;
     params.sealed_cid = info->comm_r.get();
@@ -1281,7 +1293,6 @@ namespace fc::mining {
         precommit_params->deposit,
         precommit_params->info,
         [=](const outcome::result<CID> &maybe_cid) -> void {
-          logger_->info("SUBMIT");
           if (maybe_cid.has_error()) {
             logger_->error("submitting message to precommit batcher: {}",
                            maybe_cid.error().message());

core/storage/ipfs/graphsync/impl/network/peer_context.cpp

@@ -245,7 +245,9 @@ namespace fc::storage::ipfs::graphsync {
     }
   }
 
-  void PeerContext::closeStream(const StreamPtr &stream,
+  // here stream should copy, because streams_.erase will reset original one
+  // NOLINTNEXTLINE
+  void PeerContext::closeStream(StreamPtr stream,
                                 ResponseStatusCode status) {
     auto it = streams_.find(stream);
     if (it == streams_.end()) {

core/storage/ipfs/graphsync/impl/network/peer_context.hpp

@@ -120,7 +120,7 @@ namespace fc::storage::ipfs::graphsync {
     /// Closes a stream
     /// \param stream libp2p stream
     /// \param status close reason
-    void closeStream(const StreamPtr &stream, ResponseStatusCode status);
+    void closeStream(StreamPtr stream, ResponseStatusCode status);
 
     /// Response callback, forwarded to GraphsyncImpl
     /// \param response response wire protocol object

test/core/miner/precommit_policy_test.cpp

@@ -17,22 +17,23 @@ namespace fc::mining {
   using primitives::tipset::TipsetCPtr;
   using primitives::tipset::TipsetError;
   using types::DealInfo;
+  using vm::actor::builtin::types::miner::kMinSectorExpiration;
   using vm::actor::builtin::types::miner::kWPoStProvingPeriod;
 
   class PreCommitPolicyTest : public testing::Test {
    protected:
     virtual void SetUp() {
       api_ = std::make_shared<FullNodeApi>();
 
-      duration_ = 1;
-      proving_boundary_ = 2;
+      sector_lifetime_ = std::chrono::seconds(30);
+      proving_boundary_ = 100;
 
       precommit_policy_ = std::make_shared<BasicPreCommitPolicy>(
-          api_, proving_boundary_, duration_);
+          api_, proving_boundary_, sector_lifetime_);
     }
 
     std::shared_ptr<FullNodeApi> api_;
-    ChainEpoch duration_;
+    std::chrono::seconds sector_lifetime_;
     ChainEpoch proving_boundary_;
     std::shared_ptr<PreCommitPolicy> precommit_policy_;
   };
@@ -52,7 +53,7 @@ namespace fc::mining {
       return outcome::success(tipset);
     };
 
-    auto result = block.height + kWPoStProvingPeriod + proving_boundary_ - 1;
+    auto result = block.height + kMinSectorExpiration + kWPoStProvingPeriod;
 
     EXPECT_OUTCOME_EQ(precommit_policy_->expiration({}), result);
   }
@@ -73,7 +74,8 @@ namespace fc::mining {
     };
 
     DealInfo deal1;
-    deal1.deal_schedule.end_epoch = block.height - 1;
+    deal1.deal_schedule.end_epoch =
+        block.height + kMinSectorExpiration + kWPoStProvingPeriod + 2;
     PieceInfo piece1;
     piece1.cid = "010001020002"_cid;
     DealInfo deal2;
@@ -82,10 +84,9 @@ namespace fc::mining {
                                         {.piece = piece1, .deal_info = deal1},
                                         {.piece = {}, .deal_info = deal2}};
 
-    auto result = block.height + kWPoStProvingPeriod + proving_boundary_ - 1;
     EXPECT_OUTCOME_EQ(
         precommit_policy_->expiration(gsl::span<const types::Piece>(pieces)),
-        result);
+        deal1.deal_schedule.end_epoch);
   }
 
   /**