ClientUpdates, DealStatus enum conversion

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

Author: Elestrias

core/cli/node/client.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 #include <inttypes.h>
+#include "api/full_node/node_api.hpp"
 #include "cli/node/node.hpp"
 #include "markets/storage/mk_protocol.hpp"
 #include "primitives/chain_epoch/chain_epoch.hpp"
@@ -15,12 +16,14 @@
 #include "vm/actor/actor.hpp"
 #include "vm/actor/builtin/states/verified_registry/verified_registry_actor_state.hpp"
 #include "vm/actor/builtin/v0/verified_registry/verified_registry_actor.hpp"
+#include "common/enum.hpp"
 
 namespace fc::cli::_node {
   using api::FileRef;
   using api::FullNodeApi;
   using api::ImportRes;
   using api::RetrievalOrder;
+  using api::StartDealParams;
   using boost::lexical_cast;
   using ::fc::storage::car::makeCar;
   using ::fc::storage::unixfs::wrapFile;
@@ -32,12 +35,13 @@ namespace fc::cli::_node {
   using primitives::piece::UnpaddedPieceSize;
   using proofs::padPiece;
   using storage::ipfs::ApiIpfsDatastore;
+  using vm::VMExitCode;
   using vm::actor::kVerifiedRegistryAddress;
   using vm::actor::builtin::states::VerifiedRegistryActorStatePtr;
-  using vm::VMExitCode;
-
-  const ChainEpoch kLoopback = 100; // TODO: lookback
+  using markets::storage::StorageDealStatus;
+  using common::toString;
 
+  const ChainEpoch kLoopback = 100;  // TODO: lookback
 
   StoragePower checkNotary(std::shared_ptr<FullNodeApi> api,
                            const Address &vaddr) {
@@ -224,16 +228,42 @@ namespace fc::cli::_node {
       auto duration{cliArgv<ChainEpoch>(
           argv, 3, "is a period of storing the data for, in blocks")};
       Node::Api api{argm};
-      if (duration < kMinDealDuration) throw CliError("Minimal deal duration is {}", kMinDealDuration);
-      if (duration < kMaxDealDuration) throw CliError("Max deal duration is {}", kMaxDealDuration);
-
+      if (duration < kMinDealDuration)
+        throw CliError("Minimal deal duration is {}", kMinDealDuration);
+      if (duration < kMaxDealDuration)
+        throw CliError("Max deal duration is {}", kMaxDealDuration);
+      DataRef data_ref;
       Address address_from =
           args.from ? *args.from : cliTry(api._->WalletDefaultAddress());
-      UnpaddedPieceSize piece_size{*args.man_piece_size};
-      DataRef data_ref = {.transfer_type = "graphsync",
-                          .root = data_cid,
-                          .piece_cid = *args.man_piece_cid,
-                          .piece_size = piece_size};
+      if (args.man_piece_cid) {
+        UnpaddedPieceSize piece_size{*args.man_piece_size};
+        data_ref = {.transfer_type = "manual",
+                    .root = data_cid,
+                    .piece_cid = *args.man_piece_cid,
+                    .piece_size = piece_size};
+      } else {
+        data_ref = {.transfer_type = "graphsync", .root = data_cid};
+      }
+      auto dcap =
+          cliTry(api._->StateVerifiedClientStatus(address_from, TipsetKey()),
+                 "Failed to get status of {}",
+                 address_from);
+      bool isVerified = dcap.has_value();
+      if (args.verified_deal && !isVerified)
+        throw CliError(
+            "Cannot perform verified deal using unverified address {}",
+            address_from);
+      StartDealParams deal_params = {.data = data_ref,
+                                     .wallet = address_from,
+                                     .miner = miner,
+                                     .epoch_price = price,
+                                     .min_blocks_duration = duration,
+                                     .deal_start_epoch = *args.start_epoch,
+                                     .fast_retrieval = args.fast_ret,
+                                     .verified_deal = isVerified,
+                                     .provider_collateral = *args.collateral};
+     auto proposal_cid = cliTry(api._->ClientStartDeal(deal_params));
+     fmt::print("Deal proposal CID: {}\n", cliTry(proposal_cid.toString(), "Cannot extract CID"));
     }
   };
 
@@ -364,6 +394,7 @@ namespace fc::cli::_node {
 
 <<<<<<< HEAD
 <<<<<<< HEAD
+<<<<<<< HEAD
 
 
 <<<<<<< HEAD
@@ -461,6 +492,9 @@ namespace fc::cli::_node {
 =======
   struct Node_client_inspectDeal { //TODO: continue
 >>>>>>> 3d9435d6 (FFi+ and client updates)
+=======
+  struct Node_client_inspectDeal {  // TODO: continue
+>>>>>>> ad42f96d (ClientUpdates, DealStatus enum conversion)
     struct Args {
       CLI_OPTIONAL("proposal-cid", "proposal cid of deal to be inspected", CID)
       proposal_cid;
@@ -477,25 +511,33 @@ namespace fc::cli::_node {
     }
   };
 
-  struct Node_client_dealStats{
+  struct Node_client_dealStats {
     struct Args {
       CLI_DEFAULT("newer-than",
                   "list all deals stas that was made after given period",
                   ChainEpoch,
-                  {0})newer;
-      CLI_OPTS(){
+                  {0})
+      newer;
+      CLI_OPTS() {
         Opts opts;
         newer(opts);
         return opts;
       }
     };
-    CLI_RUN(){
+    CLI_RUN() {
       Node::Api api{argm};
       auto deals = cliTry(api._->ClientListDeals());
-      for(const auto deal: deals){
-
-      }//TODO: Continue
-
+      uint64_t total_size{0};
+      std::map<StorageDealStatus, uint64_t> by_state;
+      for (const auto &deal : deals) {
+        //TODO(@Elestrias): [FIL-615] Check Creation time and since-epoch flag
+        total_size += deal.size;
+        by_state[deal.state] += deal.size;
+      }
+      fmt::print("Total: {} deals, {}", deals.size(), total_size);
+      for(const auto &[state, size]: by_state){
+          fmt::print("Deal with status {} allocates {} bytes", toString(state), size);
+      }
     }
   };
 
@@ -631,10 +673,13 @@ namespace fc::cli::_node {
            encoded_params},
           api::kPushNoSpec));
 
-          fmt::print("message sent, now waiting on cid: {}", signed_message.getCid());
-          auto mwait = cliTry(api._->StateWaitMsg(signed_message.getCid(), kMessageConfidence, kLoopback, false));
-         if (mwait.receipt.exit_code != VMExitCode::kOk) throw CliError("failed to add verified client");
-         fmt::print("Client {} was added successfully!", target);
+      fmt::print("message sent, now waiting on cid: {}",
+                 signed_message.getCid());
+      auto mwait = cliTry(api._->StateWaitMsg(
+          signed_message.getCid(), kMessageConfidence, kLoopback, false));
+      if (mwait.receipt.exit_code != VMExitCode::kOk)
+        throw CliError("failed to add verified client");
+      fmt::print("Client {} was added successfully!", target);
     }
   };
 
@@ -648,8 +693,8 @@ namespace fc::cli::_node {
     }
   };
 
-  struct Node_client_listNotaries: Empty{
-    CLI_RUN(){
+  struct Node_client_listNotaries : Empty {
+    CLI_RUN() {
       Node::Api api{argm};
       auto actor =
           cliTry(api._->StateGetActor(kVerifiedRegistryAddress, TipsetKey()),
@@ -660,16 +705,16 @@ namespace fc::cli::_node {
       auto state =
           cliTry(getCbor<VerifiedRegistryActorStatePtr>(ipfs, actor.head));
 
-      cliTry(state->verifiers.visit([=](auto &key, auto &value)->outcome::result<void>{
-        fmt::print("{}: {}", key, value);
-        return outcome::success();
-      }));
+      cliTry(state->verifiers.visit(
+          [=](auto &key, auto &value) -> outcome::result<void> {
+            fmt::print("{}: {}", key, value);
+            return outcome::success();
+          }));
     }
   };
 
-
-  struct Node_client_listClients: Empty{
-    CLI_RUN(){
+  struct Node_client_listClients : Empty {
+    CLI_RUN() {
       Node::Api api{argm};
       auto actor =
           cliTry(api._->StateGetActor(kVerifiedRegistryAddress, TipsetKey()),
@@ -680,16 +725,16 @@ namespace fc::cli::_node {
       auto state =
           cliTry(getCbor<VerifiedRegistryActorStatePtr>(ipfs, actor.head));
 
-      cliTry(state->verified_clients.visit([=](auto &key, auto &value)->outcome::result<void>{
-        fmt::print("{}: {}", key, value);
-        return outcome::success();
-      }));
+      cliTry(state->verified_clients.visit(
+          [=](auto &key, auto &value) -> outcome::result<void> {
+            fmt::print("{}: {}", key, value);
+            return outcome::success();
+          }));
     }
   };
 
-
-  struct Node_client_checkNotaryDataCap: Empty{
-    CLI_RUN(){
+  struct Node_client_checkNotaryDataCap : Empty {
+    CLI_RUN() {
       auto address{cliArgv<Address>(argv, 0, "address")};
       Node::Api api{argm};
       auto dcap = checkNotary(api._, address);

core/markets/storage/mk_protocol.hpp

@@ -135,6 +135,38 @@ namespace fc::markets::storage {
     /** deal failed with an unexpected error */
     STORAGE_DEAL_ERROR,
   };
+  inline auto &classConversionMap(StorageDealStatus &&) {
+    using E = StorageDealStatus;
+    static fc::common::ConversionTable<E, 26> table{{
+        {E::STORAGE_DEAL_UNKNOWN, "Unknown"},
+        {E::STORAGE_DEAL_PROPOSAL_NOT_FOUND, "NotFound"},
+        {E::STORAGE_DEAL_PROPOSAL_REJECTED, "ProposalRejected"},
+        {E::STORAGE_DEAL_PROPOSAL_ACCEPTED, "ProposalAccepted"},
+        {E::STORAGE_DEAL_STAGED, "Staged"},
+        {E::STORAGE_DEAL_SEALING, "Sealing"},
+        {E::STORAGE_DEAL_FINALIZING, "Finalizing"},
+        {E::STORAGE_DEAL_ACTIVE, "Active"},
+        {E::STORAGE_DEAL_EXPIRED, "Expired"},
+        {E::STORAGE_DEAL_SLASHED, "Slashed"},
+        {E::STORAGE_DEAL_REJECTING, "Rejecting"},
+        {E::STORAGE_DEAL_FAILING, "Falling"},
+        {E::STORAGE_DEAL_FUNDS_ENSURED, "FundsEnsured"},
+        {E::STORAGE_DEAL_CHECK_FOR_ACCEPTANCE, "CheckForAcceptance"},
+        {E::STORAGE_DEAL_VALIDATING, "DealValidating"},
+        {E::STORAGE_DEAL_ACCEPT_WAIT, "AcceptWait"},
+        {E::STORAGE_DEAL_START_DATA_TRANSFER, "StartDataTransfer"},
+        {E::STORAGE_DEAL_TRANSFERRING, "DealTransfering"},
+        {E::STORAGE_DEAL_WAITING_FOR_DATA, "WaitingForData"},
+        {E::STORAGE_DEAL_VERIFY_DATA, "VerifyData"},
+        {E::STORAGE_DEAL_ENSURE_PROVIDER_FUNDS, "EnsureProvidedFunds"},
+        {E::STORAGE_DEAL_PROVIDER_FUNDING, "ProviderFunding"},
+        {E::STORAGE_DEAL_CLIENT_FUNDING, "ClientFunding"},
+        {E::STORAGE_DEAL_PUBLISH, "DealPublish"},
+        {E::STORAGE_DEAL_PUBLISHING, "DealPublishing"},
+        {E::STORAGE_DEAL_ERROR, "Error"},
+    }};
+    return table;
+  }
 
   /**
    * StorageDeal is a local combination of a proposal and a current deal state