paych vouchers (#502)

Signed-off-by: turuslan <[email protected]>

Author: turuslan

core/CMakeLists.txt

@@ -17,7 +17,7 @@ add_subdirectory(fslock)
 add_subdirectory(markets)
 add_subdirectory(miner)
 add_subdirectory(node)
-add_subdirectory(payment_channel_manager)
+add_subdirectory(paych)
 add_subdirectory(power)
 add_subdirectory(primitives)
 add_subdirectory(proofs)

core/api/full_node/make.cpp

@@ -43,6 +43,7 @@
 #include "vm/runtime/env.hpp"
 #include "vm/runtime/impl/tipset_randomness.hpp"
 #include "vm/state/impl/state_tree_impl.hpp"
+#include "vm/state/resolve_key.hpp"
 #include "vm/toolchain/toolchain.hpp"
 
 #define MOVE(x)  \
@@ -85,8 +86,6 @@ namespace fc::api {
   using vm::actor::builtin::types::market::DealState;
   using vm::actor::builtin::types::storage_power::kConsensusMinerMinPower;
   using vm::interpreter::InterpreterCache;
-  using vm::message::kDefaultGasLimit;
-  using vm::message::kDefaultGasPrice;
   using vm::runtime::Env;
   using vm::state::StateTreeImpl;
   using vm::toolchain::Toolchain;
@@ -155,11 +154,7 @@ namespace fc::api {
     }
 
     outcome::result<Address> accountKey(const Address &id) {
-      OUTCOME_TRY(actor, state_tree.get(id));
-      OUTCOME_TRY(
-          state,
-          getCbor<AccountActorStatePtr>(state_tree.getStore(), actor.head));
-      return state->address;
+      return resolveKey(state_tree, id);
     }
 
     // TODO (a.chernyshov) make explicit
@@ -439,7 +434,7 @@ namespace fc::api {
             for (const auto &[peer, maybe_response] : all_calls) {
               if (maybe_response.has_error()) {
                 kNodeApiLogger->error("Error when query peer {}",
-                              maybe_response.error().message());
+                                      maybe_response.error().message());
               } else {
                 result.emplace_back(maybe_response.value());
               }
@@ -489,7 +484,7 @@ namespace fc::api {
           [=](outcome::result<void> res) {
             if (res.has_error()) {
               kNodeApiLogger->error("Error in ClientRetrieve {}",
-                            res.error().message());
+                                    res.error().message());
               return cb(res.error());
             }
             kNodeApiLogger->info("retrieval deal done");
@@ -519,9 +514,7 @@ namespace fc::api {
         -> outcome::result<UnsignedMessage> {
       if (msg.from.isId()) {
         OUTCOME_TRY(context, tipsetContext(tsk));
-        OUTCOME_TRYA(msg.from,
-                     vm::runtime::resolveKey(
-                         context.state_tree, context, msg.from, false));
+        OUTCOME_TRYA(msg.from, context.accountKey(msg.from));
       }
       OUTCOME_TRY(mpool->estimate(
           msg, spec ? spec->max_fee : storage::mpool::kDefaultMaxFee));
@@ -657,9 +650,7 @@ namespace fc::api {
                                 auto &spec) -> outcome::result<SignedMessage> {
       OUTCOME_TRY(context, tipsetContext({}));
       if (message.from.isId()) {
-        OUTCOME_TRYA(message.from,
-                     vm::runtime::resolveKey(
-                         context.state_tree, ipld, message.from, false));
+        OUTCOME_TRYA(message.from, context.accountKey(message.from));
       }
       OUTCOME_TRY(mpool->estimate(
           message, spec ? spec->max_fee : storage::mpool::kDefaultMaxFee));
@@ -1272,10 +1263,6 @@ namespace fc::api {
       }
       return key_store->verify(address, data, signature);
     };
-    /**
-     * Payment channel methods are initialized with
-     * PaymentChannelManager::makeApi(Api &api)
-     */
     return api;
-  }  // namespace fc::api
+  }
 }  // namespace fc::api

core/api/full_node/make.hpp

@@ -14,7 +14,7 @@
 #include "storage/chain/chain_store.hpp"
 #include "storage/chain/msg_waiter.hpp"
 #include "storage/keystore/keystore.hpp"
-#include "storage/leveldb/prefix.hpp"
+#include "storage/map_prefix/prefix.hpp"
 #include "storage/mpool/mpool.hpp"
 #include "vm/runtime/env_context.hpp"
 
@@ -33,7 +33,8 @@ namespace fc::api {
   using sync::PubSubGate;
   using vm::runtime::EnvironmentContext;
 
-  const static common::Logger kNodeApiLogger = common::createLogger("Full Node API");
+  const static common::Logger kNodeApiLogger =
+      common::createLogger("Full Node API");
 
   outcome::result<IpldObject> getNode(const std::shared_ptr<Ipld> &ipld,
                                       const CID &root,

core/api/impl/paych_get.hpp

@@ -6,10 +6,10 @@
 #pragma once
 
 #include "api/full_node/node_api.hpp"
-#include "payment_channel_manager/impl/maker.hpp"
+#include "paych/maker.hpp"
 
 namespace fc::api {
-  inline void implPaychGet(
+  inline void fillPaychGet(
       const std::shared_ptr<FullNodeApi> &api,
       const std::shared_ptr<paych_maker::PaychMaker> &maker) {
     api->PaychGet = [=](auto &&cb,

core/api/impl/paych_voucher.hpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "api/full_node/node_api.hpp"
+#include "paych/vouchers.hpp"
+
+namespace fc::api {
+  inline void fillPaychVoucher(
+      const std::shared_ptr<FullNodeApi> &api,
+      const std::shared_ptr<paych_vouchers::PaychVouchers> &vouchers) {
+    using paych_vouchers::actorHash;
+    api->PaychAllocateLane =
+        [=](const Address &address) -> outcome::result<LaneId> {
+      OUTCOME_TRY(paych, actorHash(address));
+      return vouchers->nextLane(paych);
+    };
+    api->PaychVoucherAdd =
+        [=](const Address &address,
+            const SignedVoucher &voucher,
+            const Bytes &proof,
+            const TokenAmount &min_delta) -> outcome::result<TokenAmount> {
+      if (!proof.empty()) {
+        return ERROR_TEXT("PaychVoucherAdd proof not supported");
+      }
+      OUTCOME_TRY(paych, actorHash(address));
+      OUTCOME_TRY(voucher_paych, actorHash(voucher.channel));
+      if (paych != voucher_paych) {
+        return ERROR_TEXT("PaychVoucherAdd wrong address");
+      }
+      return vouchers->add(voucher, min_delta);
+    };
+    api->PaychVoucherCheckValid =
+        [=](const Address &address,
+            const SignedVoucher &voucher) -> outcome::result<void> {
+      OUTCOME_TRY(paych, actorHash(address));
+      OUTCOME_TRY(voucher_paych, actorHash(voucher.channel));
+      if (paych != voucher_paych) {
+        return ERROR_TEXT("PaychVoucherCheckValid wrong address");
+      }
+      return vouchers->check(voucher);
+    };
+    api->PaychVoucherCreate =
+        [=](const Address &address,
+            const TokenAmount &amount,
+            LaneId lane) -> outcome::result<SignedVoucher> {
+      OUTCOME_TRY(paych, actorHash(address));
+      return vouchers->make(paych, lane, amount);
+    };
+  }
+}  // namespace fc::api

core/api/rpc/json.hpp

@@ -16,7 +16,6 @@
 #include "common/enum.hpp"
 #include "common/libp2p/peer/cbor_peer_info.hpp"
 #include "miner/main/type.hpp"
-#include "payment_channel_manager/payment_channel_manager.hpp"
 #include "primitives/address/address_codec.hpp"
 #include "primitives/cid/cid_of_cbor.hpp"
 #include "sector_storage/stores/storage.hpp"

core/cbor_blake/ipld_version.hpp

@@ -26,12 +26,15 @@ namespace fc {
   };
 
   // TODO(turuslan): refactor Ipld to CbIpld
-  inline IpldPtr withVersion(IpldPtr ipld, ChainEpoch height) {
-    const auto version{actorVersion(height)};
+  inline IpldPtr withVersion(IpldPtr ipld, ActorVersion version) {
     if (ipld->actor_version != version) {
       ipld = std::make_shared<IpldProxy>(ipld);
       ipld->actor_version = version;
     }
     return ipld;
   }
+
+  inline IpldPtr withVersion(const IpldPtr &ipld, ChainEpoch height) {
+    return withVersion(ipld, actorVersion(height));
+  }
 }  // namespace fc

core/data_transfer/dt.cpp

@@ -9,6 +9,7 @@
 
 #include "common/libp2p/cbor_stream.hpp"
 #include "common/ptr.hpp"
+#include "storage/ipfs/graphsync/extension_dedup.hpp"
 
 #define MOVE(x)  \
   x {            \
@@ -226,17 +227,21 @@ namespace fc::data_transfer {
         peer,
         root,
         selector.b,
-        {makeExt(DataTransferMessage{DataTransferRequest{
-            root,
-            MessageType::kNewMessage,
-            false,
-            false,
-            true,
-            selector,
-            CborRaw{std::move(voucher)},
-            std::move(type),
-            dtid,
-        }})},
+        {
+            makeExt(DataTransferMessage{DataTransferRequest{
+                root,
+                MessageType::kNewMessage,
+                false,
+                false,
+                true,
+                selector,
+                CborRaw{std::move(voucher)},
+                std::move(type),
+                dtid,
+            }}),
+            storage::ipfs::graphsync::extension::dedup::make(
+                std::to_string(dtid)),
+        },
         [this, peer, MOVE(on_cid), sub](auto, auto ext) {
           if (auto _ext{gsns::Extension::find(gsns::kResponseMetadataProtocol,
                                               ext)}) {

core/markets/retrieval/provider/CMakeLists.txt

@@ -13,6 +13,7 @@ target_link_libraries(retrieval_market_provider
     cbor_stream
     tipset
     ipld_traverser
+    map_prefix
     memory_indexed_car
     piece
     piece_data

core/markets/retrieval/provider/impl/retrieval_provider_impl.hpp

@@ -16,7 +16,7 @@
 #include "miner/miner.hpp"
 #include "storage/ipld/memory_indexed_car.hpp"
 #include "storage/ipld/traverser.hpp"
-#include "storage/leveldb/prefix.hpp"
+#include "storage/map_prefix/prefix.hpp"
 #include "storage/piece/piece_storage.hpp"
 
 namespace fc::markets::retrieval::provider {
@@ -71,11 +71,12 @@ namespace fc::markets::retrieval::provider {
     void onProposal(const PeerDtId &pdtid,
                     const PeerGsId &pgsid,
                     const DealProposal &proposal);
-    void onPayment(const std::shared_ptr<DealState>& deal, const DealPayment &payment);
-    void doUnseal(const std::shared_ptr<DealState>& deal);
-    void doBlocks(const std::shared_ptr<DealState>& deal);
-    void doComplete(const std::shared_ptr<DealState>& deal);
-    bool hasOwed(const std::shared_ptr<DealState>& deal);
+    void onPayment(const std::shared_ptr<DealState> &deal,
+                   const DealPayment &payment);
+    void doUnseal(const std::shared_ptr<DealState> &deal);
+    void doBlocks(const std::shared_ptr<DealState> &deal);
+    void doComplete(const std::shared_ptr<DealState> &deal);
+    bool hasOwed(const std::shared_ptr<DealState> &deal);
     void doFail(const std::shared_ptr<DealState> &deal, std::string error);
 
     void start() override;