Actor methods (#671)

Signed-off-by: Mikhail Tagirov <[email protected]>

Author: Mikhail Tagirov

core/api/full_node/make.cpp

@@ -28,11 +28,11 @@
 #include "proofs/impl/proof_engine_impl.hpp"
 #include "storage/car/car.hpp"
 #include "storage/unixfs/unixfs.hpp"
+#include "vm/actor/builtin/methods/market.hpp"
 #include "vm/actor/builtin/states/miner/miner_actor_state.hpp"
 #include "vm/actor/builtin/types/market/deal.hpp"
 #include "vm/actor/builtin/types/market/policy.hpp"
 #include "vm/actor/builtin/types/storage_power/policy.hpp"
-#include "vm/actor/builtin/v0/market/market_actor.hpp"
 #include "vm/actor/builtin/v5/market/validate.hpp"
 #include "vm/actor/builtin/v5/miner/monies.hpp"
 #include "vm/message/impl/message_signer_impl.hpp"
@@ -74,6 +74,7 @@ namespace fc::api {
   using vm::state::StateTreeImpl;
   using vm::toolchain::Toolchain;
   using vm::version::getNetworkVersion;
+  namespace market = vm::actor::builtin::market;
 
   void beaconEntriesForBlock(const DrandSchedule &schedule,
                              Beaconizer &beaconizer,
@@ -415,22 +416,16 @@ namespace fc::api {
       }
       // TODO(a.chernyshov): method should use fund manager batch reserve
       // and release funds requests for market actor.
-      OUTCOME_TRY(
-          encoded_params,
-          codec::cbor::encode(
-              vm::actor::builtin::v0::market::AddBalance::Params{address}));
-      UnsignedMessage unsigned_message{
-          kStorageMarketAddress,
-          wallet,
-          {},
-          amount,
-          0,
-          0,
-          // TODO (a.chernyshov) there is v0 actor method number, but the
-          // actor methods do not depend on version. Should be changed to
-          // general method number when methods number are made general
-          vm::actor::builtin::v0::market::AddBalance::Number,
-          encoded_params};
+      OUTCOME_TRY(encoded_params,
+                  codec::cbor::encode(market::AddBalance::Params{address}));
+      UnsignedMessage unsigned_message{kStorageMarketAddress,
+                                       wallet,
+                                       {},
+                                       amount,
+                                       0,
+                                       0,
+                                       market::AddBalance::Number,
+                                       encoded_params};
       OUTCOME_TRY(signed_message,
                   api->MpoolPushMessage(unsigned_message, api::kPushNoSpec));
       return signed_message.getCid();
@@ -755,21 +750,18 @@ namespace fc::api {
     };
     api->MarketAddBalance =
         [=](auto &address, auto &wallet, auto &amount) -> outcome::result<CID> {
-      OUTCOME_TRY(
-          encoded_params,
-          codec::cbor::encode(
-              vm::actor::builtin::v0::market::AddBalance::Params{address}));
+      OUTCOME_TRY(encoded_params,
+                  codec::cbor::encode(market::AddBalance::Params{address}));
       OUTCOME_TRY(signed_message,
                   api->MpoolPushMessage(
-                      vm::message::UnsignedMessage(
-                          kStorageMarketAddress,
-                          wallet,
-                          0,
-                          amount,
-                          0,
-                          0,
-                          vm::actor::builtin::v0::market::AddBalance::Number,
-                          encoded_params),
+                      vm::message::UnsignedMessage(kStorageMarketAddress,
+                                                   wallet,
+                                                   0,
+                                                   amount,
+                                                   0,
+                                                   0,
+                                                   market::AddBalance::Number,
+                                                   encoded_params),
                       api::kPushNoSpec));
       return signed_message.getCid();
     };
@@ -1087,7 +1079,7 @@ namespace fc::api {
 
     api->StateVerifiedClientStatus = [=](const Address &address,
                                          const TipsetKey &tipset_key)
-        -> outcome::result<boost::optional<StoragePower>> {
+        -> outcome::result<boost::optional<DataCap>> {
       OUTCOME_TRY(context, tipsetContext(tipset_key, true));
       OUTCOME_TRY(id, context.state_tree.lookupId(address));
       OUTCOME_TRY(state, context.verifiedRegistryState());

core/api/full_node/node_api.hpp

@@ -48,6 +48,7 @@ namespace fc::api {
   using markets::storage::client::import_manager::Import;
   using primitives::BigInt;
   using primitives::ChainEpoch;
+  using primitives::DataCap;
   using primitives::DealId;
   using primitives::EpochDuration;
   using primitives::GasAmount;
@@ -765,7 +766,7 @@ namespace fc::api {
      */
     API_METHOD(StateVerifiedClientStatus,
                jwt::kReadPermission,
-               boost::optional<StoragePower>,
+               boost::optional<DataCap>,
                const Address &,
                const TipsetKey &)
 

core/cli/node/client.hpp

@@ -23,9 +23,7 @@
 #include "storage/ipld/memory_indexed_car.hpp"
 #include "storage/unixfs/unixfs.hpp"
 #include "vm/actor/actor.hpp"
-#include "vm/actor/builtin/states/verified_registry/verified_registry_actor_state.hpp"
 #include "vm/actor/builtin/types/market/policy.hpp"
-#include "vm/actor/builtin/v0/verified_registry/verified_registry_actor.hpp"
 #include "vm/state/impl/state_tree_impl.hpp"
 
 namespace fc::cli::cli_node {
@@ -348,7 +346,7 @@ namespace fc::cli::cli_node {
       if (not boost::filesystem::exists(path_in)) {
         throw CliError("Input file does not exist.\n");
       }
-      if (not boost::filesystem::is_regular_file(path_in)){
+      if (not boost::filesystem::is_regular_file(path_in)) {
         throw CliError("Provided path does not leads to regular file.\n");
       }
 

core/cli/node/filplus.hpp

@@ -4,7 +4,10 @@
  */
 
 #pragma once
+
 #include "api/full_node/node_api.hpp"
+#include "vm/actor/builtin/methods/verified_registry.hpp"
+#include "vm/actor/builtin/states/verified_registry/verified_registry_actor_state.hpp"
 
 namespace fc::cli::cli_node {
   using api::MsgWait;
@@ -14,6 +17,7 @@ namespace fc::cli::cli_node {
   using vm::actor::kVerifiedRegistryAddress;
   using vm::actor::builtin::states::VerifiedRegistryActorStatePtr;
   using vm::message::SignedMessage;
+  namespace verifreg = vm::actor::builtin::verifreg;
 
   StoragePower checkNotary(const std::shared_ptr<FullNodeApi> &api,
                            const Address &vaddr) {
@@ -62,18 +66,17 @@ namespace fc::cli::cli_node {
             allowance);
 
       auto encoded_params = cliTry(codec::cbor::encode(
-          vm::actor::builtin::v0::verified_registry::AddVerifiedClient::Params{
-              target, allowance}));
-      SignedMessage signed_message = cliTry(api->MpoolPushMessage(
-          {kVerifiedRegistryAddress,
-           *args.from,
-           {},
-           0,
-           0,
-           0,
-           vm::actor::builtin::v0::verified_registry::AddVerifiedClient::Number,
-           encoded_params},
-          api::kPushNoSpec));
+          verifreg::AddVerifiedClient::Params{target, allowance}));
+      SignedMessage signed_message =
+          cliTry(api->MpoolPushMessage({kVerifiedRegistryAddress,
+                                        *args.from,
+                                        {},
+                                        0,
+                                        0,
+                                        0,
+                                        verifreg::AddVerifiedClient::Number,
+                                        encoded_params},
+                                       api::kPushNoSpec));
 
       fmt::print("message sent, now waiting on cid: {}\n",
                  signed_message.getCid());
@@ -139,19 +142,17 @@ namespace fc::cli::cli_node {
           cliTry(getCbor<VerifiedRegistryActorStatePtr>(ipfs, actor.head));
 
       auto encoded_params = cliTry(codec::cbor::encode(
-          vm::actor::builtin::v0::verified_registry::AddVerifier::Params{
-              *args.from, *args.amount
-          }));
-      const SignedMessage signed_message = cliTry(api->MpoolPushMessage(
-          {kVerifiedRegistryAddress,
-           state->root_key,
-           {},
-           0,
-           0,
-           0,
-           vm::actor::builtin::v0::verified_registry::AddVerifier::Number,
-           encoded_params},
-          api::kPushNoSpec));
+          verifreg::AddVerifier::Params{*args.from, *args.amount}));
+      const SignedMessage signed_message =
+          cliTry(api->MpoolPushMessage({kVerifiedRegistryAddress,
+                                        state->root_key,
+                                        {},
+                                        0,
+                                        0,
+                                        0,
+                                        verifreg::AddVerifier::Number,
+                                        encoded_params},
+                                       api::kPushNoSpec));
       const MsgWait message_wait =
           cliTry(api->StateWaitMsg(signed_message.getCid(), 1, 10, false),
                  "Wait message");

core/common/smoothing/alpha_beta_filter.hpp

@@ -22,6 +22,14 @@ namespace fc::common::smoothing {
   struct FilterEstimate {
     BigInt position;
     BigInt velocity;
+
+    inline bool operator==(const FilterEstimate &other) const {
+      return position == other.position && velocity == other.velocity;
+    }
+
+    inline bool operator!=(const FilterEstimate &other) const {
+      return !(*this == other);
+    }
   };
   CBOR_TUPLE(FilterEstimate, position, velocity)
 

core/markets/storage/chain_events/impl/chain_events_impl.cpp

@@ -6,21 +6,20 @@
 #include "markets/storage/chain_events/impl/chain_events_impl.hpp"
 #include "common/outcome_fmt.hpp"
 #include "storage/ipfs/api_ipfs_datastore/api_ipfs_datastore.hpp"
+#include "vm/actor/builtin/methods/miner.hpp"
 #include "vm/actor/builtin/states/miner/miner_actor_state.hpp"
-#include "vm/actor/builtin/v7/miner/miner_actor.hpp"
+#include "vm/actor/builtin/types/miner/replica_update.hpp"
+#include "vm/actor/builtin/types/miner/sector_info.hpp"
 
 namespace fc::markets::storage::chain_events {
   using primitives::RleBitset;
   using primitives::tipset::HeadChangeType;
   using vm::VMExitCode;
+  using vm::actor::builtin::states::MinerActorStatePtr;
+  using vm::actor::builtin::types::miner::ReplicaUpdate;
   using vm::actor::builtin::types::miner::SectorPreCommitInfo;
-  using vm::actor::builtin::v5::miner::PreCommitBatch;
-  using vm::actor::builtin::v5::miner::PreCommitSector;
-  using vm::actor::builtin::v5::miner::ProveCommitAggregate;
-  using vm::actor::builtin::v5::miner::ProveCommitSector;
-  using vm::actor::builtin::v7::miner::ProveReplicaUpdates;
-  using vm::actor::builtin::v7::miner::ReplicaUpdate;
   using vm::message::SignedMessage;
+  namespace miner = vm::actor::builtin::miner;
 
   ChainEventsImpl::ChainEventsImpl(std::shared_ptr<FullNodeApi> api,
                                    IsDealPrecommited is_deal_precommited)
@@ -36,9 +35,7 @@ namespace fc::markets::storage::chain_events {
             std::make_shared<fc::storage::ipfs::ApiIpfsDatastore>(api)};
         OUTCOME_TRY(network, api->StateNetworkVersion(tsk));
         ipld->actor_version = actorVersion(network);
-        OUTCOME_TRY(state,
-                    getCbor<vm::actor::builtin::states::MinerActorStatePtr>(
-                        ipld, actor.head));
+        OUTCOME_TRY(state, getCbor<MinerActorStatePtr>(ipld, actor.head));
         boost::optional<SectorNumber> result;
         constexpr auto kStop{std::errc::interrupted};
         const auto visit{state->precommitted_sectors.visit(
@@ -162,9 +159,10 @@ namespace fc::markets::storage::chain_events {
                   return cb(r.receipt.exit_code);
                 }
                 if (update) {
-                  OUTCOME_CB(auto result,
-                             codec::cbor::decode<ProveReplicaUpdates::Result>(
-                                 r.receipt.return_value));
+                  OUTCOME_CB(
+                      auto result,
+                      codec::cbor::decode<miner::ProveReplicaUpdates::Result>(
+                          r.receipt.return_value));
                   if (!result.has(sector)) {
                     return cb(ERROR_TEXT("ProveReplicaUpdates failed"));
                   }
@@ -207,32 +205,34 @@ namespace fc::markets::storage::chain_events {
     const auto on_update{[&](const ReplicaUpdate &update) {
       on_deals(update.deals, update.sector, true);
     }};
-    if (message.method == PreCommitSector::Number) {
-      OUTCOME_TRY(param,
-                  codec::cbor::decode<PreCommitSector::Params>(message.params));
+    if (message.method == miner::PreCommitSector::Number) {
+      OUTCOME_TRY(
+          param,
+          codec::cbor::decode<miner::PreCommitSector::Params>(message.params));
       on_precommit(param);
-    } else if (message.method == PreCommitBatch::Number) {
+    } else if (message.method == miner::PreCommitSectorBatch::Number) {
       OUTCOME_TRY(param,
-                  codec::cbor::decode<PreCommitBatch::Params>(message.params));
+                  codec::cbor::decode<miner::PreCommitSectorBatch::Params>(
+                      message.params));
       for (const auto &precommit : param.sectors) {
         on_precommit(precommit);
       }
-    } else if (message.method == ProveCommitSector::Number) {
-      OUTCOME_TRY(
-          param,
-          codec::cbor::decode<ProveCommitSector::Params>(message.params));
+    } else if (message.method == miner::ProveCommitSector::Number) {
+      OUTCOME_TRY(param,
+                  codec::cbor::decode<miner::ProveCommitSector::Params>(
+                      message.params));
       on_commit(param.sector);
-    } else if (message.method == ProveCommitAggregate::Number) {
-      OUTCOME_TRY(
-          param,
-          codec::cbor::decode<ProveCommitAggregate::Params>(message.params));
+    } else if (message.method == miner::ProveCommitAggregate::Number) {
+      OUTCOME_TRY(param,
+                  codec::cbor::decode<miner::ProveCommitAggregate::Params>(
+                      message.params));
       for (const auto &sector : param.sectors) {
         on_commit(sector);
       }
-    } else if (message.method == ProveReplicaUpdates::Number) {
-      OUTCOME_TRY(
-          param,
-          codec::cbor::decode<ProveReplicaUpdates::Params>(message.params));
+    } else if (message.method == miner::ProveReplicaUpdates::Number) {
+      OUTCOME_TRY(param,
+                  codec::cbor::decode<miner::ProveReplicaUpdates::Params>(
+                      message.params));
       for (const auto &update : param.updates) {
         on_update(update);
       }

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

@@ -19,6 +19,7 @@
 #include "markets/storage/client/import_manager/import_manager.hpp"
 #include "markets/storage/storage_datatransfer_voucher.hpp"
 #include "storage/ipld/memory_indexed_car.hpp"
+#include "vm/actor/builtin/methods/market.hpp"
 #include "vm/actor/builtin/types/market/publish_deals_result.hpp"
 #include "vm/message/message.hpp"
 
@@ -58,9 +59,9 @@ namespace fc::markets::storage::client {
   using primitives::sector::RegisteredSealProof;
   using vm::VMExitCode;
   using vm::actor::kStorageMarketAddress;
-  using vm::actor::builtin::v0::market::PublishStorageDeals;
   using vm::message::SignedMessage;
   using vm::message::UnsignedMessage;
+  namespace market = vm::actor::builtin::market;
 
   StorageMarketClientImpl::StorageMarketClientImpl(
       std::shared_ptr<Host> host,
@@ -422,14 +423,14 @@ namespace fc::markets::storage::client {
       deal->message = "Receiver is not storage market actor";
       return false;
     }
-    if (publish_message.method != PublishStorageDeals::Number) {
+    if (publish_message.method != market::PublishStorageDeals::Number) {
       deal->message = "Wrong method called";
       return false;
     }
 
     // check publish contains proposal cid
     OUTCOME_TRY(params,
-                codec::cbor::decode<PublishStorageDeals::Params>(
+                codec::cbor::decode<market::PublishStorageDeals::Params>(
                     publish_message.params));
     const auto &proposals{params.deals};
     const auto it = std::find(