Check publish proposal deal id in deal publish message in storage market (#500)

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

Author: Alexey-N-Chernyshov

core/api/full_node/make.cpp

@@ -875,13 +875,13 @@ namespace fc::api {
         [=](auto deal_id, auto &tipset_key) -> outcome::result<StorageDeal> {
       OUTCOME_TRY(context, tipsetContext(tipset_key));
       OUTCOME_TRY(state, context.marketState());
-      OUTCOME_TRY(deal, state->proposals.get(deal_id));
+      OUTCOME_TRY(proposal, state->proposals.get(deal_id));
       OUTCOME_TRY(deal_state, state->states.tryGet(deal_id));
       if (!deal_state) {
         deal_state = DealState{
             kChainEpochUndefined, kChainEpochUndefined, kChainEpochUndefined};
       }
-      return StorageDeal{deal, *deal_state};
+      return StorageDeal{proposal, *deal_state};
     };
     api->StateMinerActiveSectors =
         [=](auto &miner,

core/const.hpp

@@ -38,7 +38,7 @@ namespace fc {
   constexpr uint64_t kFilReserve{300000000};
   constexpr uint64_t kFilecoinPrecision{1000000000000000000};
   constexpr auto kGasLimitOverestimation{1.25};
-  constexpr auto kMessageConfidence{5};
+  constexpr EpochDuration kMessageConfidence{5};
   const TokenAmount kMinimumBaseFee{100};
   constexpr auto kPackingEfficiencyDenom{5};
   constexpr auto kPackingEfficiencyNum{4};

core/markets/storage/client/impl/storage_market_client_impl.cpp

@@ -10,6 +10,7 @@
 #include <libp2p/protocol/common/asio/asio_scheduler.hpp>
 
 #include "codec/cbor/cbor_codec.hpp"
+#include "common/enum.hpp"
 #include "common/libp2p/peer/peer_info_helper.hpp"
 #include "common/outcome_fmt.hpp"
 #include "common/ptr.hpp"
@@ -402,19 +403,18 @@ namespace fc::markets::storage::client {
     if (msg_state.receipt.exit_code != VMExitCode::kOk) {
       deal->message =
           "Publish deal exit code "
-          + std::to_string(static_cast<uint64_t>(msg_state.receipt.exit_code));
+          + std::to_string(common::to_int(msg_state.receipt.exit_code));
       return false;
     }
 
     // check if published
     OUTCOME_TRY(publish_message, api_->ChainGetMessage(deal->publish_message));
-    OUTCOME_TRY(chain_head, api_->ChainHead());
     OUTCOME_TRY(
         miner_info,
         api_->StateMinerInfo(deal->client_deal_proposal.proposal.provider,
-                             chain_head->key));
+                             msg_state.tipset));
     OUTCOME_TRY(from_id_address,
-                api_->StateLookupID(publish_message.from, chain_head->key));
+                api_->StateLookupID(publish_message.from, msg_state.tipset));
     if (from_id_address != miner_info.worker) {
       deal->message = "Publisher is not storage provider";
       return false;
@@ -432,8 +432,8 @@ namespace fc::markets::storage::client {
     OUTCOME_TRY(params,
                 codec::cbor::decode<PublishStorageDeals::Params>(
                     publish_message.params));
-    auto &proposals{params.deals};
-    auto it = std::find(
+    const auto &proposals{params.deals};
+    const auto it = std::find(
         proposals.begin(), proposals.end(), deal->client_deal_proposal);
     if (it == proposals.end()) {
       OUTCOME_TRY(proposal_cid_str, deal->proposal_cid.toString());
@@ -444,7 +444,7 @@ namespace fc::markets::storage::client {
 
     // get proposal id from publish call return
     size_t index = std::distance(proposals.begin(), it);
-    OUTCOME_TRY(network, api_->StateNetworkVersion(chain_head->key));
+    OUTCOME_TRY(network, api_->StateNetworkVersion(msg_state.tipset));
     OUTCOME_TRY(
         deal_id,
         vm::actor::builtin::types::market::publishDealsResult(
@@ -527,7 +527,7 @@ namespace fc::markets::storage::client {
           SELF_FSM_HALT_ON_ERROR(result, "Wait for funding error", deal);
           if (result.value().receipt.exit_code != VMExitCode::kOk) {
             deal->message = "Funding exit code "
-                            + std::to_string(static_cast<uint64_t>(
+                            + std::to_string(common::to_int(
                                 result.value().receipt.exit_code));
             SELF_FSM_SEND(deal, ClientEvent::ClientEventFailed);
             return;

core/markets/storage/provider/impl/provider_impl.cpp

@@ -36,7 +36,6 @@
   }
 
 namespace fc::markets::storage::provider {
-  using api::MsgWait;
   using data_transfer::Selector;
   using fc::storage::piece::DealInfo;
   using fc::storage::piece::PayloadLocation;
@@ -61,7 +60,8 @@ namespace fc::markets::storage::provider {
       std::shared_ptr<ChainEvents> chain_events,
       Address miner_actor_address,
       std::shared_ptr<PieceIO> piece_io,
-      std::shared_ptr<FileStore> filestore)
+      std::shared_ptr<FileStore> filestore,
+      std::shared_ptr<DealInfoManager> deal_info_manager)
       : host_{std::move(host)},
         context_{std::move(context)},
         stored_ask_{std::move(stored_ask)},
@@ -73,7 +73,8 @@ namespace fc::markets::storage::provider {
         piece_storage_{std::move(piece_storage)},
         filestore_{std::move(filestore)},
         ipld_{std::move(ipld)},
-        datatransfer_{std::move(datatransfer)} {}
+        datatransfer_{std::move(datatransfer)},
+        deal_info_manager_{std::move(deal_info_manager)} {}
 
   std::shared_ptr<MinerDeal> StorageProviderImpl::getDealPtr(
       const CID &proposal_cid) {
@@ -640,33 +641,23 @@ namespace fc::markets::storage::provider {
       ProviderEvent event,
       StorageDealStatus from,
       StorageDealStatus to) {
+    assert(deal->publish_cid.has_value());
+
     api_->StateWaitMsg(
-        [self{shared_from_this()}, deal, to](outcome::result<MsgWait> result) {
+        [self{shared_from_this()}, deal, to](
+            outcome::result<MsgWait> msg_state) {
+          const auto maybe_deal_id =
+              self->deal_info_manager_->dealIdFromPublishDealsMsg(
+                  msg_state.value(), deal->client_deal_proposal.proposal);
           SELF_FSM_HALT_ON_ERROR(
-              result, "Publish storage deal message error", deal);
-          if (result.value().receipt.exit_code != VMExitCode::kOk) {
-            deal->message = "Publish storage deal exit code "
-                            + std::to_string(static_cast<uint64_t>(
-                                result.value().receipt.exit_code));
-            SELF_FSM_SEND(deal, ProviderEvent::ProviderEventFailed);
-            return;
-          }
-          // TODO(turuslan): v6
-          auto maybe_res = codec::cbor::decode<PublishStorageDeals::Result>(
-              result.value().receipt.return_value);
-          SELF_FSM_HALT_ON_ERROR(
-              maybe_res, "Publish storage deal decode result error", deal);
-          if (maybe_res.value().deals.size() != 1) {
-            deal->message = "Publish storage deal result size error";
-            SELF_FSM_SEND(deal, ProviderEvent::ProviderEventFailed);
-            return;
-          }
-          deal->deal_id = maybe_res.value().deals.front();
+              maybe_deal_id, "Looking for publish deal message", deal);
+          deal->deal_id = maybe_deal_id.value();
           deal->state = to;
           SELF_FSM_SEND(deal, ProviderEvent::ProviderEventDealPublished);
         },
         deal->publish_cid.get(),
-        kMessageConfidence,
+        // Wait for deal to be published (plus additional time for confidence)
+        kMessageConfidence * 2,
         api::kLookbackNoLimit,
         true);
   }
@@ -717,7 +708,7 @@ namespace fc::markets::storage::provider {
   }
 
   void StorageProviderImpl::onProviderEventDealCompleted(
-      const std::shared_ptr<MinerDeal>& deal,
+      const std::shared_ptr<MinerDeal> &deal,
       ProviderEvent event,
       StorageDealStatus from,
       StorageDealStatus to) {