Ferature/snap fsm (#655)

Signed-off-by: Alexey Chernyshov <[email protected]>

Co-authored-by: Artem Iurin <[email protected]>

Author: Alexey-N-Chernyshov

core/api/rpc/json.hpp

@@ -2114,20 +2114,4 @@ namespace fc::api {
     Get(j, "MinerPeer", v.peer);
   }
 
-  JSON_ENCODE(std::set<TaskType>) {
-    Value j{rapidjson::kObjectType};
-    j.MemberReserve(v.size(), allocator);
-    for (auto &pair : v) {
-      std::map<std::string, std::string> value;
-      Set(j, pair, value, allocator);
-    }
-    return j;
-  }
-
-  JSON_DECODE(std::set<TaskType>) {
-    for (auto it = j.MemberBegin(); it != j.MemberEnd(); ++it) {
-      v.emplace(TaskType(AsString(it->name)));
-    }
-  }
-
 }  // namespace fc::api

core/api/storage_miner/return_api.hpp

@@ -89,5 +89,11 @@ namespace fc::api {
             const boost::optional<CallError> &call_error) {
           return scheduler->returnResult(call_id, {proof, call_error});
         };
+
+    api->ReturnFinalizeReplicaUpdate =
+        [=](const CallId &call_id,
+            const boost::optional<CallError> &call_error) {
+          return scheduler->returnResult(call_id, {{}, call_error});
+        };
   }
 }  // namespace fc::api

core/api/storage_miner/storage_api.cpp

@@ -114,7 +114,7 @@ namespace fc::api {
           sector_info->precommit_message,
           sector_info->message,
           sector_info->invalid_proofs,
-          miner->getSealing()->isMarkedForUpgrade(id),
+          sector_info->update,
       };
       if (not show_onchain_info) {
         return api_sector_info;
@@ -199,6 +199,16 @@ namespace fc::api {
       });
     };
 
+    api->SectorMarkForUpgrade = [=](SectorNumber sector,
+                                    bool snap_deal) -> outcome::result<void> {
+      if (snap_deal) {
+        return miner->getSealing()->markForSnapUpgrade(sector);
+      }
+      return ERROR_TEXT(
+          "Old capacity sector upgrade deprecated, use snap deals capacity "
+          "sector upgrade");
+    };
+
     api->Version = [] {
       return api::VersionResult{kMinerVersion, kMinerApiVersion, 0};
     };

core/api/storage_miner/storage_api.hpp

@@ -220,6 +220,11 @@ namespace fc::api {
                void,
                const CallId &,
                const boost::optional<CallError> &)
+    API_METHOD(ReturnFinalizeReplicaUpdate,
+               jwt::kAdminPermission,
+               void,
+               const CallId &,
+               const boost::optional<CallError> &)
     API_METHOD(ReturnMoveStorage,
                jwt::kAdminPermission,
                void,
@@ -259,6 +264,11 @@ namespace fc::api {
                const CallId &,
                Proof,
                const boost::optional<CallError> &)
+    API_METHOD(SectorMarkForUpgrade,
+               jwt::kAdminPermission,
+               void,
+               SectorNumber,
+               bool /* snap_deal */)
 
     API_METHOD(WorkerConnect, jwt::kAdminPermission, void, const std::string &);
   };
@@ -307,13 +317,15 @@ namespace fc::api {
     f(a.ReturnSealCommit1);
     f(a.ReturnSealCommit2);
     f(a.ReturnFinalizeSector);
+    f(a.ReturnFinalizeReplicaUpdate);
     f(a.ReturnMoveStorage);
     f(a.ReturnUnsealPiece);
     f(a.ReturnReadPiece);
     f(a.ReturnFetch);
     f(a.ReturnReplicaUpdate);
     f(a.ReturnProveReplicaUpdate1);
     f(a.ReturnProveReplicaUpdate2);
+    f(a.SectorMarkForUpgrade);
     f(a.WorkerConnect);
   }
 }  // namespace fc::api

core/api/worker_api.hpp

@@ -7,11 +7,13 @@
 
 #include "api/utils.hpp"
 #include "api/version.hpp"
+#include "codec/json/basic_coding.hpp"
 #include "common/outcome.hpp"
 #include "primitives/jwt/jwt.hpp"
 #include "sector_storage/worker.hpp"
 
 namespace fc::api {
+  using codec::json::CodecSetAsMap;
   using primitives::jwt::kAdminPermission;
   using primitives::piece::MetaPieceData;
   using primitives::piece::PieceInfo;
@@ -74,6 +76,11 @@ namespace fc::api {
                const CID &,
                const CID &,
                const Update1Output &)
+    API_METHOD(FinalizeReplicaUpdate,
+               kAdminPermission,
+               CallId,
+               const SectorRef &,
+               const std::vector<Range> &)
 
     API_METHOD(Info, kAdminPermission, primitives::WorkerInfo)
 
@@ -115,7 +122,7 @@ namespace fc::api {
 
     API_METHOD(StorageAddLocal, kAdminPermission, void, const std::string &)
 
-    API_METHOD(TaskTypes, kAdminPermission, std::set<primitives::TaskType>)
+    API_METHOD(TaskTypes, kAdminPermission, CodecSetAsMap<primitives::TaskType>)
 
     API_METHOD(UnsealPiece,
                kAdminPermission,
@@ -137,6 +144,7 @@ namespace fc::api {
     f(a.ReplicaUpdate);
     f(a.ProveReplicaUpdate1);
     f(a.ProveReplicaUpdate2);
+    f(a.FinalizeReplicaUpdate);
     f(a.Info);
     f(a.MoveStorage);
     f(a.Paths);

core/codec/json/basic_coding.hpp

@@ -36,6 +36,14 @@ namespace fc::codec::json {
   using rapidjson::Value;
   using base64 = cppcodec::base64_rfc4648;
 
+  /**
+   * Set is encoded as an array: "[a, b, c]", but this class allows to encode
+   * set as map: "{a:{}, b:{}, c:{}}. Used for lotus compatibility.
+   */
+  template <typename T>
+  class CodecSetAsMap : public std::set<T> {};
+
+
   template <typename T>
   T innerDecode(const Value &j);
 
@@ -279,4 +287,22 @@ namespace fc::codec::json {
       v.emplace(innerDecode<T>(it));
     }
   }
+
+  template <typename T>
+  JSON_ENCODE(CodecSetAsMap<T>) {
+    Value j{rapidjson::kObjectType};
+    j.MemberReserve(v.size(), allocator);
+    for (auto &pair : v) {
+      std::map<T, std::string> value;
+      Set(j, pair, value, allocator);
+    }
+    return j;
+  }
+
+  template <typename T>
+  JSON_DECODE(CodecSetAsMap<T>) {
+    for (auto it = j.MemberBegin(); it != j.MemberEnd(); ++it) {
+      v.emplace(T(AsString(it->name)));
+    }
+  }
 }  // namespace fc::codec::json

core/common/map_utils.hpp

@@ -0,0 +1,26 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <map>
+
+namespace fc::common {
+
+  /**
+   * @returns map value if present, otherwise default_value
+   */
+  template <template <class, class, class...> class C,
+            typename K,
+            typename V,
+            typename... Args>
+  const V &getOrDefault(const C<K, V, Args...> &map,
+                 const K &key,
+                 const V &default_value) {
+    const auto &found = map.find(key);
+    if (found == map.end()) return default_value;
+    return found->second;
+  }
+}  // namespace fc::common

core/const.cpp

@@ -57,7 +57,8 @@ namespace fc {
 
 namespace fc::vm::actor::builtin::types::market {
   DEFINE(kDealUpdatesInterval) = static_cast<EpochDuration>(kEpochsInDay);
-}
+  DEFINE(kDealMinDuration) = static_cast<EpochDuration>(kEpochsInDay) * 180;
+}  // namespace fc::vm::actor::builtin::types::market
 
 namespace fc::vm::actor::builtin::types::miner {
   DEFINE(kWPoStProvingPeriod) = kEpochsInDay;

core/markets/storage/deal_protocol.hpp

@@ -94,6 +94,7 @@ namespace fc::miner {
     fee_config->max_precommit_batch_gas_fee.per_sector =
         TokenAmount{"2000000000000000"};
     fee_config->max_precommit_gas_fee = TokenAmount{"25000000000000000"};
+    fee_config->max_commit_gas_fee = TokenAmount{"50000000000000000"};
 
     std::shared_ptr<PreCommitBatcher> precommit_batcher =
         std::make_shared<PreCommitBatcherImpl>(std::chrono::seconds(60),