Typed actor method (#124)

Signed-off-by: turuslan <turuslan.devbox@gmail.com>

Author: turuslan

core/vm/actor/actor_encoding.hpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_ENCODING_HPP
+#define CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_ENCODING_HPP
+
+#include "codec/cbor/cbor.hpp"
+#include "common/outcome.hpp"
+#include "vm/actor/actor.hpp"
+#include "vm/exit_code/exit_code.hpp"
+#include "vm/runtime/runtime_types.hpp"
+
+namespace fc::vm::actor {
+  using runtime::InvocationOutput;
+
+  /// Type for empty params and result
+  struct None {};
+  CBOR_ENCODE(None, none) {
+    return s;
+  }
+  CBOR_DECODE(None, none) {
+    return s;
+  }
+
+  /// Decode actor params, raises appropriate error
+  template <typename T>
+  outcome::result<T> decodeActorParams(MethodParams params_bytes) {
+    if constexpr (std::is_same_v<T, None>) {
+      return T{};
+    }
+    auto maybe_params = codec::cbor::decode<T>(params_bytes);
+    if (!maybe_params) {
+      return VMExitCode::DECODE_ACTOR_PARAMS_ERROR;
+    }
+    return maybe_params;
+  }
+
+  /// Encode actor params, raises appropriate error
+  template <typename T>
+  outcome::result<MethodParams> encodeActorParams(const T &params) {
+    auto maybe_bytes = codec::cbor::encode(params);
+    if (!maybe_bytes) {
+      return VMExitCode::ENCODE_ACTOR_PARAMS_ERROR;
+    }
+    return MethodParams{maybe_bytes.value()};
+  }
+
+  template <typename T>
+  outcome::result<T> decodeActorReturn(const InvocationOutput &result) {
+    if constexpr (std::is_same_v<T, None>) {
+      return T{};
+    }
+    return codec::cbor::decode<T>(result.return_value);
+  }
+
+  template <typename T>
+  outcome::result<InvocationOutput> encodeActorReturn(const T &result) {
+    OUTCOME_TRY(encoded, codec::cbor::encode(result));
+    return InvocationOutput{Buffer{encoded}};
+  }
+}  // namespace fc::vm::actor
+
+#endif  // CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_ENCODING_HPP

core/vm/actor/actor_method.hpp

@@ -9,15 +9,19 @@
 #include "codec/cbor/cbor.hpp"
 #include "common/outcome.hpp"
 #include "vm/actor/actor.hpp"
+#include "vm/actor/actor_encoding.hpp"
 #include "vm/exit_code/exit_code.hpp"
 #include "vm/runtime/runtime.hpp"
 
-#define ACTOR_METHOD(name)                                 \
-  outcome::result<InvocationOutput> name(Runtime &runtime, \
-                                         const MethodParams &params)
+/// Declare actor method function
+#define ACTOR_METHOD_DECL() \
+  static outcome::result<Result> call(Runtime &, const Params &);
 
-namespace fc::vm::actor {
+/// Define actor method function
+#define ACTOR_METHOD_IMPL(M) \
+  outcome::result<M::Result> M::call(Runtime &runtime, const Params &params)
 
+namespace fc::vm::actor {
   using common::Buffer;
   using runtime::InvocationOutput;
   using runtime::Runtime;
@@ -35,31 +39,26 @@ namespace fc::vm::actor {
   /// Actor methods exported by number
   using ActorExports = std::map<MethodNumber, ActorMethod>;
 
-  /// Decode actor params, raises appropriate error
-  template <typename T>
-  outcome::result<T> decodeActorParams(MethodParams params_bytes) {
-    auto maybe_params = codec::cbor::decode<T>(params_bytes);
-    if (!maybe_params) {
-      return VMExitCode::DECODE_ACTOR_PARAMS_ERROR;
-    }
-    return maybe_params;
-  }
-
-  using runtime::encodeActorParams;
+  /// Actor method base class
+  template <uint64_t number>
+  struct ActorMethodBase {
+    using Params = None;
+    using Result = None;
+    static constexpr MethodNumber Number{number};
+  };
 
-  template <typename T>
-  outcome::result<T> decodeActorReturn(const InvocationOutput &result) {
-    OUTCOME_TRY(decoded,
-                codec::cbor::decode<T>(result.return_value.toVector()));
-    return std::move(decoded);
+  /// Generate export table entry
+  template <typename M>
+  auto exportMethod() {
+    return std::make_pair(
+        M::Number,
+        ActorMethod{[](auto &runtime,
+                       auto &params) -> outcome::result<InvocationOutput> {
+          OUTCOME_TRY(params2, decodeActorParams<typename M::Params>(params));
+          OUTCOME_TRY(result, M::call(runtime, params2));
+          return encodeActorReturn(result);
+        }});
   }
-
-  template <typename T>
-  outcome::result<InvocationOutput> encodeActorReturn(const T &result) {
-    OUTCOME_TRY(encoded, codec::cbor::encode(result));
-    return InvocationOutput{Buffer{encoded}};
-  }
-
 }  // namespace fc::vm::actor
 
 #endif  // CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_METHOD_HPP

core/vm/actor/builtin/account/account_actor.cpp

@@ -42,13 +42,12 @@ namespace fc::vm::actor::builtin::account {
     return account_actor_state.address;
   }
 
-  ACTOR_METHOD(pubkeyAddress) {
+  ACTOR_METHOD_IMPL(PubkeyAddress) {
     OUTCOME_TRY(state, runtime.getCurrentActorStateCbor<AccountActorState>());
-    OUTCOME_TRY(result, codec::cbor::encode(state.address));
-    return InvocationOutput{Buffer{result}};
+    return state.address;
   }
 
   const ActorExports exports = {
-      {kPubkeyAddressMethodNumber, ActorMethod(pubkeyAddress)},
+      exportMethod<PubkeyAddress>(),
   };
 }  // namespace fc::vm::actor::builtin::account

core/vm/actor/builtin/account/account_actor.hpp

@@ -17,11 +17,10 @@ namespace fc::vm::actor::builtin::account {
   using primitives::address::Protocol;
   using state::StateTree;
 
-  constexpr MethodNumber kPubkeyAddressMethodNumber{2};
-
   struct AccountActorState {
     Address address;
   };
+  CBOR_TUPLE(AccountActorState, address)
 
   /// Account actors represent actors without code
   struct AccountActor {
@@ -38,9 +37,10 @@ namespace fc::vm::actor::builtin::account {
         const std::shared_ptr<StateTree> &state_tree, const Address &address);
   };
 
-  CBOR_TUPLE(AccountActorState, address)
-
-  ACTOR_METHOD(pubkeyAddress);
+  struct PubkeyAddress : ActorMethodBase<2> {
+    using Result = Address;
+    ACTOR_METHOD_DECL();
+  };
 
   extern const ActorExports exports;
 }  // namespace fc::vm::actor::builtin::account

core/vm/actor/builtin/cron/cron_actor.cpp

@@ -12,9 +12,9 @@ namespace fc::vm::actor::builtin::cron {
    * EpochTick
    */
   std::vector<CronTableEntry> entries = {
-      {kStoragePowerAddress, {storage_power::kOnEpochTickEndMethodNumber}}};
+      {kStoragePowerAddress, {storage_power::OnEpochTickEnd::Number}}};
 
-  ACTOR_METHOD(epochTick) {
+  ACTOR_METHOD_IMPL(EpochTick) {
     if ((runtime.getMessage().get().from != kCronAddress)) {
       return VMExitCode::CRON_ACTOR_WRONG_CALL;
     }
@@ -26,6 +26,6 @@ namespace fc::vm::actor::builtin::cron {
   }
 
   const ActorExports exports = {
-      {kEpochTickMethodNumber, ActorMethod(epochTick)},
+      exportMethod<EpochTick>(),
   };
 }  // namespace fc::vm::actor::builtin::cron

core/vm/actor/builtin/cron/cron_actor.hpp

@@ -15,16 +15,16 @@ namespace fc::vm::actor::builtin::cron {
     MethodNumber method_num{};
   };
 
-  constexpr MethodNumber kEpochTickMethodNumber{2};
-
   /**
    * @brief EpochTick executes built-in periodic actions, run at every Epoch.
    * @param actor from Lotus(doesn't use)
    * @param runtime is virtual machine context
    * @param params from Lotus(doesn't use)
    * @return success or error
    */
-  ACTOR_METHOD(epochTick);
+  struct EpochTick : ActorMethodBase<2> {
+    ACTOR_METHOD_DECL();
+  };
 
   extern const ActorExports exports;
 

core/vm/actor/builtin/init/init_actor.cpp

@@ -22,12 +22,11 @@ namespace fc::vm::actor::builtin::init {
     return Address::makeFromId(id);
   }
 
-  ACTOR_METHOD(exec) {
-    OUTCOME_TRY(exec_params, decodeActorParams<ExecParams>(params));
-    if (!isBuiltinActor(exec_params.code)) {
+  ACTOR_METHOD_IMPL(Exec) {
+    if (!isBuiltinActor(params.code)) {
       return VMExitCode::INIT_ACTOR_NOT_BUILTIN_ACTOR;
     }
-    if (isSingletonActor(exec_params.code)) {
+    if (isSingletonActor(params.code)) {
       return VMExitCode::INIT_ACTOR_SINGLETON_ACTOR;
     }
     OUTCOME_TRY(runtime.chargeGas(runtime::kInitActorExecCost));
@@ -40,16 +39,14 @@ namespace fc::vm::actor::builtin::init {
     OUTCOME_TRY(id_address, init_actor.addActor(store, actor_address));
     OUTCOME_TRY(runtime.createActor(
         id_address,
-        Actor{exec_params.code, ActorSubstateCID{kEmptyObjectCid}, 0, 0}));
-    OUTCOME_TRY(runtime.send(id_address,
-                             kConstructorMethodNumber,
-                             exec_params.params,
-                             message.value));
-    ExecReturn exec_return{id_address, actor_address};
-    OUTCOME_TRY(output, encodeActorReturn(exec_return));
+        Actor{params.code, ActorSubstateCID{kEmptyObjectCid}, 0, 0}));
+    OUTCOME_TRY(runtime.send(
+        id_address, kConstructorMethodNumber, params.params, message.value));
     OUTCOME_TRY(runtime.commitState(init_actor));
-    return std::move(output);
+    return Result{id_address, actor_address};
   }
 
-  const ActorExports exports{{kExecMethodNumber, ActorMethod(exec)}};
+  const ActorExports exports{
+      exportMethod<Exec>(),
+  };
 }  // namespace fc::vm::actor::builtin::init

core/vm/actor/builtin/init/init_actor.hpp

@@ -23,30 +23,30 @@ namespace fc::vm::actor::builtin::init {
     CID address_map{};
     uint64_t next_id{};
   };
-
   CBOR_TUPLE(InitActorState, address_map, next_id)
 
-  constexpr MethodNumber kExecMethodNumber{2};
-
-  struct ExecParams {
-    CodeId code;
-    MethodParams params;
-  };
-
-  struct ExecReturn {
-    Address id_address;      // The canonical ID-based address for the actor
-    Address robust_address;  // A more expensive but re-org-safe address for the
-                             // newly created actor
+  struct Exec : ActorMethodBase<2> {
+    struct Params {
+      CodeId code;
+      MethodParams params;
+    };
+    struct Result {
+      Address id_address;      // The canonical ID-based address for the actor
+      Address robust_address;  // A more expensive but re-org-safe address for
+                               // the newly created actor
+    };
+    ACTOR_METHOD_DECL();
   };
+  CBOR_TUPLE(Exec::Params, code, params)
+  CBOR_TUPLE(Exec::Result, id_address, robust_address)
 
-  ACTOR_METHOD(exec);
+  inline bool operator==(const Exec::Result &lhs, const Exec::Result &rhs) {
+    return lhs.id_address == rhs.id_address
+           && lhs.robust_address == rhs.robust_address;
+  }
 
   extern const ActorExports exports;
 
-  CBOR_TUPLE(ExecParams, code, params)
-
-  CBOR_TUPLE(ExecReturn, id_address, robust_address)
-
 }  // namespace fc::vm::actor::builtin::init
 
 #endif  // CPP_FILECOIN_CORE_VM_ACTOR_INIT_ACTOR_HPP

core/vm/actor/builtin/market/actor.hpp

@@ -13,31 +13,36 @@
 namespace fc::vm::actor::builtin::market {
   using primitives::ChainEpoch;
   using primitives::DealId;
+  using primitives::DealWeight;
   using primitives::SectorSize;
 
-  constexpr MethodNumber kVerifyDealsOnSectorProveCommitMethodNumber{6};
-  constexpr MethodNumber kOnMinerSectorsTerminateMethodNumber{7};
-  constexpr MethodNumber kComputeDataCommitmentMethodNumber{8};
-
-  struct VerifyDealsOnSectorProveCommitParams {
-    std::vector<DealId> deals;
-    ChainEpoch sector_expiry;
+  struct VerifyDealsOnSectorProveCommit : ActorMethodBase<6> {
+    struct Params {
+      std::vector<DealId> deals;
+      ChainEpoch sector_expiry;
+    };
+    using Result = DealWeight;
+    ACTOR_METHOD_DECL();
   };
+  CBOR_TUPLE(VerifyDealsOnSectorProveCommit::Params, deals, sector_expiry)
 
-  struct OnMinerSectorsTerminateParams {
-    std::vector<DealId> deals;
+  struct OnMinerSectorsTerminate : ActorMethodBase<7> {
+    struct Params {
+      std::vector<DealId> deals;
+    };
+    ACTOR_METHOD_DECL();
   };
-
-  struct ComputeDataCommitmentParams {
-    std::vector<DealId> deals;
-    SectorSize sector_size;
+  CBOR_TUPLE(OnMinerSectorsTerminate::Params, deals)
+
+  struct ComputeDataCommitment : ActorMethodBase<8> {
+    struct Params {
+      std::vector<DealId> deals;
+      SectorSize sector_size;
+    };
+    using Result = CID;
+    ACTOR_METHOD_DECL();
   };
-
-  CBOR_TUPLE(VerifyDealsOnSectorProveCommitParams, deals, sector_expiry)
-
-  CBOR_TUPLE(OnMinerSectorsTerminateParams, deals)
-
-  CBOR_TUPLE(ComputeDataCommitmentParams, deals, sector_size)
+  CBOR_TUPLE(ComputeDataCommitment::Params, deals, sector_size)
 }  // namespace fc::vm::actor::builtin::market
 
 #endif  // CPP_FILECOIN_CORE_VM_ACTOR_BUILTIN_MARKET_ACTOR_HPP