Feature/retrieval market v1.0.0 (#549)

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

Author: Alexey-N-Chernyshov

core/codec/cbor/cbor_types.cpp

@@ -4,85 +4,9 @@
  */
 
 #include "codec/cbor/cbor_codec.hpp"
-#include "markets/retrieval/protocols/retrieval_protocol.hpp"
 #include "primitives/address/address_codec.hpp"
 #include "storage/ipfs/graphsync/extension.hpp"
 
-namespace fc::markets::retrieval {
-  using codec::cbor::CborDecodeStream;
-  using codec::cbor::CborEncodeStream;
-
-  CBOR2_ENCODE(DealProposalParams::Named) {
-    auto m{CborEncodeStream::map()};
-    m["Selector"] << v.selector;
-    m["PieceCID"] << v.piece;
-    m["PricePerByte"] << v.price_per_byte;
-    m["PaymentInterval"] << v.payment_interval;
-    m["PaymentIntervalIncrease"] << v.payment_interval_increase;
-    m["UnsealPrice"] << v.unseal_price;
-    return s << m;
-  }
-  CBOR2_DECODE(DealProposalParams::Named) {
-    auto m{s.map()};
-    CborDecodeStream::named(m, "Selector") >> v.selector;
-    CborDecodeStream::named(m, "PieceCID") >> v.piece;
-    CborDecodeStream::named(m, "PricePerByte") >> v.price_per_byte;
-    CborDecodeStream::named(m, "PaymentInterval") >> v.payment_interval;
-    CborDecodeStream::named(m, "PaymentIntervalIncrease")
-        >> v.payment_interval_increase;
-    CborDecodeStream::named(m, "UnsealPrice") >> v.unseal_price;
-    return s;
-  }
-
-  CBOR2_ENCODE(DealProposal::Named) {
-    auto m{CborEncodeStream::map()};
-    m["PayloadCID"] << v.payload_cid;
-    m["ID"] << v.deal_id;
-    m["Params"] << static_cast<const DealProposalParams::Named &>(v.params);
-    return s << m;
-  }
-  CBOR2_DECODE(DealProposal::Named) {
-    auto m{s.map()};
-    CborDecodeStream::named(m, "PayloadCID") >> v.payload_cid;
-    CborDecodeStream::named(m, "ID") >> v.deal_id;
-    CborDecodeStream::named(m, "Params")
-        >> *(static_cast<DealProposalParams::Named *>(&v.params));
-    return s;
-  }
-
-  CBOR2_ENCODE(DealResponse::Named) {
-    auto m{CborEncodeStream::map()};
-    m["Status"] << v.status;
-    m["ID"] << v.deal_id;
-    m["PaymentOwed"] << v.payment_owed;
-    m["Message"] << v.message;
-    return s << m;
-  }
-  CBOR2_DECODE(DealResponse::Named) {
-    auto m{s.map()};
-    CborDecodeStream::named(m, "Status") >> v.status;
-    CborDecodeStream::named(m, "ID") >> v.deal_id;
-    CborDecodeStream::named(m, "PaymentOwed") >> v.payment_owed;
-    CborDecodeStream::named(m, "Message") >> v.message;
-    return s;
-  }
-
-  CBOR2_ENCODE(DealPayment::Named) {
-    auto m{CborEncodeStream::map()};
-    m["ID"] << v.deal_id;
-    m["PaymentChannel"] << v.payment_channel;
-    m["PaymentVoucher"] << v.payment_voucher;
-    return s << m;
-  }
-  CBOR2_DECODE(DealPayment::Named) {
-    auto m{s.map()};
-    CborDecodeStream::named(m, "ID") >> v.deal_id;
-    CborDecodeStream::named(m, "PaymentChannel") >> v.payment_channel;
-    CborDecodeStream::named(m, "PaymentVoucher") >> v.payment_voucher;
-    return s;
-  }
-}  // namespace fc::markets::retrieval
-
 namespace fc::storage::ipfs::graphsync {
   using codec::cbor::CborDecodeStream;
   using codec::cbor::CborEncodeStream;

core/markets/retrieval/client/impl/retrieval_client_impl.cpp

@@ -9,7 +9,7 @@
 #include "common/libp2p/peer/peer_info_helper.hpp"
 
 namespace fc::markets::retrieval::client {
-  DealState::DealState(const DealProposal &proposal,
+  DealState::DealState(const DealProposalV1_0_0 &proposal,
                        const IpldPtr &ipld,
                        RetrieveResponseHandler handler,
                        Address client_wallet,
@@ -45,18 +45,20 @@ namespace fc::markets::retrieval::client {
                                   const QueryResponseHandler &cb) {
     OUTCOME_CB(auto peer, getPeerInfo(provider_peer));
     host_->newStream(
-        peer, kQueryProtocolId, [=, self{shared_from_this()}](auto stream_res) {
+        peer,
+        kQueryProtocolIdV1_0_0,
+        [=, self{shared_from_this()}](auto stream_res) {
           OUTCOME_CB1(stream_res);
           self->logger_->debug("connected to provider ID "
                                + peerInfoToPrettyString(peer));
           auto stream{std::make_shared<CborStream>(stream_res.value())};
-          stream->write(request, [=](auto written_res) {
+          stream->write(QueryRequestV1_0_0{request}, [=](auto written_res) {
             if (written_res.has_error()) {
               stream->close();
               cb(written_res.error());
               return;
             }
-            stream->template read<QueryResponse>([=](auto response) {
+            stream->template read<QueryResponseV1_0_0>([=](auto response) {
               stream->close();
               cb(std::move(response));
             });
@@ -80,17 +82,15 @@ namespace fc::markets::retrieval::client {
       const Address &client_wallet,
       const Address &miner_wallet,
       const RetrieveResponseHandler &handler) {
-    DealProposal::Named proposal{{.payload_cid = payload_cid,
-                                  .deal_id = next_deal_id++,
-                                  .params = deal_params}};
+    DealProposalV1_0_0 proposal{payload_cid, next_deal_id++, deal_params};
     auto deal{std::make_shared<DealState>(
         proposal, ipfs_, handler, client_wallet, miner_wallet, total_funds)};
     OUTCOME_TRY(peer_info, getPeerInfo(provider_peer));
     deal->pdtid = datatransfer_->pull(
         peer_info,
         payload_cid,
         deal_params.selector,
-        DealProposal::Named::type,
+        DealProposalV1_0_0::type,
         codec::cbor::encode(proposal).value(),
         [this, deal](auto &type, auto voucher) {
           onPullData(deal, type, voucher);
@@ -103,7 +103,7 @@ namespace fc::markets::retrieval::client {
   void RetrievalClientImpl::onPullData(const std::shared_ptr<DealState> &deal,
                                        const std::string &type,
                                        BytesIn voucher) {
-    OUTCOME_EXCEPT(res, codec::cbor::decode<DealResponse::Named>(voucher));
+    OUTCOME_EXCEPT(res, codec::cbor::decode<DealResponseV1_0_0>(voucher));
     auto after{[=](auto &res) {
       if (res.status == DealStatus::kDealStatusCompleted) {
         deal->handler(outcome::success());
@@ -214,11 +214,11 @@ namespace fc::markets::retrieval::client {
     }
     datatransfer_->pullOut(
         deal_state->pdtid,
-        DealPayment::Named::type,
+        DealPaymentV1_0_0::type,
         codec::cbor::encode(
-            DealPayment::Named{{deal_state->proposal.deal_id,
-                                deal_state->payment_channel_address,
-                                maybe_voucher.value()}})
+            DealPaymentV1_0_0{{deal_state->proposal.deal_id,
+                               deal_state->payment_channel_address,
+                               maybe_voucher.value()}})
             .value());
     deal_state->state.pay(payment_requested);
   }

core/markets/retrieval/client/impl/retrieval_client_impl.hpp

@@ -33,14 +33,14 @@ namespace fc::markets::retrieval::client {
    * State of ongoing retrieval deal.
    */
   struct DealState {
-    DealState(const DealProposal &proposal,
+    DealState(const DealProposalV1_0_0 &proposal,
               const IpldPtr &ipld,
               RetrieveResponseHandler handler,
               Address client_wallet,
               Address miner_wallet,
               TokenAmount total_funds);
 
-    DealProposal proposal;
+    DealProposalV1_0_0 proposal;
     State state;
     PeerDtId pdtid;
     bool accepted{}, all_blocks{};

core/markets/retrieval/client/retrieval_client.hpp

@@ -17,7 +17,7 @@
 namespace fc::markets::retrieval::client {
   using libp2p::peer::PeerInfo;
   using QueryResponseHandler =
-      std::function<void(outcome::result<QueryResponse>)>;
+      std::function<void(outcome::result<QueryResponseV1_0_0>)>;
   using RetrieveResponseHandler = std::function<void(outcome::result<void>)>;
 
   /*

core/markets/retrieval/protocols/query_protocol.hpp

@@ -8,20 +8,26 @@
 #include <string>
 
 #include <libp2p/peer/protocol.hpp>
+#include "codec/cbor/cbor_codec.hpp"
 #include "codec/cbor/streams_annotation.hpp"
 #include "primitives/address/address.hpp"
 #include "primitives/address/address_codec.hpp"
 #include "primitives/cid/cid.hpp"
 #include "primitives/types.hpp"
 
 namespace fc::markets::retrieval {
+  using codec::cbor::CborDecodeStream;
+  using codec::cbor::CborEncodeStream;
   using primitives::TokenAmount;
   using primitives::address::Address;
 
-  /**
-   * @brief Query Protocol ID V0
-   */
-  const libp2p::peer::Protocol kQueryProtocolId = "/fil/retrieval/qry/0.0.1";
+  /** Query Protocol ID v0.0.1 */
+  const libp2p::peer::Protocol kQueryProtocolIdV0_0_1 =
+      "/fil/retrieval/qry/0.0.1";
+
+  /** Query Protocol ID v1.0.0 */
+  const libp2p::peer::Protocol kQueryProtocolIdV1_0_0 =
+      "/fil/retrieval/qry/1.0.0";
 
   /**
    * @struct Request from client to provider
@@ -32,19 +38,54 @@ namespace fc::markets::retrieval {
     boost::optional<CID> piece_cid;
   };
 
+  struct QueryParamsV0_0_1 : public QueryParams {};
+
+  CBOR_TUPLE(QueryParamsV0_0_1, piece_cid)
+
+  struct QueryParamsV1_0_0 : public QueryParams {};
+
+  inline CBOR2_ENCODE(QueryParamsV1_0_0) {
+    auto m{CborEncodeStream::orderedMap()};
+    m["PieceCID"] << v.piece_cid;
+    return s << m;
+  }
+
+  inline CBOR2_DECODE(QueryParamsV1_0_0) {
+    auto m{s.map()};
+    CborDecodeStream::named(m, "PieceCID") >> v.piece_cid;
+    return s;
+  }
+
+  CBOR_TUPLE(QueryParams, piece_cid)
+
   struct QueryRequest {
-    /* V0 protocol */
     /* Identifier of the requested item */
     CID payload_cid;
 
-    /* V1 protocol */
     /* Additional params */
     QueryParams params;
   };
 
-  CBOR_TUPLE(QueryParams, piece_cid)
+  struct QueryRequestV0_0_1 : public QueryRequest {};
+
+  CBOR_TUPLE(QueryRequestV0_0_1, payload_cid, params)
 
-  CBOR_TUPLE(QueryRequest, payload_cid, params)
+  struct QueryRequestV1_0_0 : public QueryRequest {};
+
+  inline CBOR2_ENCODE(QueryRequestV1_0_0) {
+    auto m{CborEncodeStream::orderedMap()};
+    m["PayloadCID"] << v.payload_cid;
+    m["QueryParams"] << QueryParamsV1_0_0{v.params};
+    return s << m;
+  }
+
+  inline CBOR2_DECODE(QueryRequestV1_0_0) {
+    auto m{s.map()};
+    CborDecodeStream::named(m, "PayloadCID") >> v.payload_cid;
+    v.params =
+        CborDecodeStream::named(m, "QueryParams").get<QueryParamsV1_0_0>();
+    return s;
+  }
 
   /**
    * @enum Status of the query response
@@ -106,7 +147,9 @@ namespace fc::markets::retrieval {
     TokenAmount unseal_price;
   };
 
-  CBOR_TUPLE(QueryResponse,
+  struct QueryResponseV0_0_1 : public QueryResponse {};
+
+  CBOR_TUPLE(QueryResponseV0_0_1,
              response_status,
              item_status,
              item_size,
@@ -115,6 +158,37 @@ namespace fc::markets::retrieval {
              payment_interval,
              interval_increase,
              message,
-             unseal_price);
+             unseal_price)
+
+  struct QueryResponseV1_0_0 : public QueryResponse {};
+
+  inline CBOR2_ENCODE(QueryResponseV1_0_0) {
+    auto m{CborEncodeStream::orderedMap()};
+    m["Status"] << v.response_status;
+    m["PieceCIDFound"] << v.item_status;
+    m["Size"] << v.item_size;
+    m["PaymentAddress"] << v.payment_address;
+    m["MinPricePerByte"] << v.min_price_per_byte;
+    m["MaxPaymentInterval"] << v.payment_interval;
+    m["MaxPaymentIntervalIncrease"] << v.interval_increase;
+    m["Message"] << v.message;
+    m["UnsealPrice"] << v.unseal_price;
+    return s << m;
+  }
+
+  inline CBOR2_DECODE(QueryResponseV1_0_0) {
+    auto m{s.map()};
+    CborDecodeStream::named(m, "Status") >> v.response_status;
+    CborDecodeStream::named(m, "PieceCIDFound") >> v.item_status;
+    CborDecodeStream::named(m, "Size") >> v.item_size;
+    CborDecodeStream::named(m, "PaymentAddress") >> v.payment_address;
+    CborDecodeStream::named(m, "MinPricePerByte") >> v.min_price_per_byte;
+    CborDecodeStream::named(m, "MaxPaymentInterval") >> v.payment_interval;
+    CborDecodeStream::named(m, "MaxPaymentIntervalIncrease")
+        >> v.interval_increase;
+    CborDecodeStream::named(m, "Message") >> v.message;
+    CborDecodeStream::named(m, "UnsealPrice") >> v.unseal_price;
+    return s;
+  }
 
 }  // namespace fc::markets::retrieval