Init actor VM method (#79)

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

Author: turuslan

core/primitives/address/address.cpp

@@ -6,6 +6,7 @@
 #include "primitives/address/address.hpp"
 
 #include "common/visitor.hpp"
+#include "crypto/blake2/blake2b160.hpp"
 
 OUTCOME_CPP_DEFINE_CATEGORY(fc::primitives::address, AddressError, e) {
   using fc::primitives::address::AddressError;
@@ -23,6 +24,7 @@ OUTCOME_CPP_DEFINE_CATEGORY(fc::primitives::address, AddressError, e) {
 }
 
 namespace fc::primitives::address {
+  using crypto::blake2b::blake2b_160;
 
   bool Address::isKeyType() const {
     return visit_in_place(
@@ -47,6 +49,11 @@ namespace fc::primitives::address {
     return {TESTNET, id};
   }
 
+  Address Address::makeActorExecAddress(gsl::span<const uint8_t> data) {
+    // TODO(turuslan): FIL-118 remove hardcoded TESTNET
+    return {TESTNET, ActorExecHash{blake2b_160(data).value()}};
+  }
+
   bool operator==(const Address &lhs, const Address &rhs) {
     return lhs.network == rhs.network && lhs.getProtocol() == rhs.getProtocol()
            && lhs.data == rhs.data;

core/primitives/address/address.hpp

@@ -68,6 +68,8 @@ namespace fc::primitives::address {
     /// id - number assigned to actors in a Filecoin Chain
     static Address makeFromId(uint64_t id);
 
+    static Address makeActorExecAddress(gsl::span<const uint8_t> data);
+
     Network network;
     Payload data;
   };

core/vm/actor/actor_method.hpp

@@ -23,6 +23,9 @@ namespace fc::vm::actor {
   /// Actor methods exported by number
   using ActorExports = std::map<MethodNumber, ActorMethod>;
 
+  /// Reserved method number for constructor
+  constexpr MethodNumber kConstructorMethodNumber{1};
+
   constexpr VMExitCode DECODE_ACTOR_PARAMS_ERROR{1};
 
   /// Decode actor params, raises appropriate error

core/vm/actor/cron_actor.cpp

@@ -5,21 +5,19 @@
 
 #include "vm/actor/cron_actor.hpp"
 
-namespace fc::vm::actor {
-
-  using vm::actor::MethodNumber;
-  using vm::runtime::InvocationOutput;
-  using vm::runtime::Runtime;
-
-  constexpr MethodNumber kEpochTickMethodNumber{2};
-
-  std::vector<CronTableEntry> CronActor::entries = {
-      {kStoragePowerAddress, SpaMethods::CHECK_PROOF_SUBMISSIONS}};
-
-  outcome::result<InvocationOutput> CronActor::epochTick(
-      const Actor &actor, Runtime &runtime, const MethodParams &params) {
-    if ((runtime.getMessage()->from != kCronAddress)) {
-      return WRONG_CALL;
+namespace fc::vm::actor::cron_actor {
+  /**
+   * Entries is a set of actors (and corresponding methods) to call during
+   * EpochTick
+   */
+  std::vector<CronTableEntry> entries = {
+      {kStoragePowerAddress, {SpaMethods::CHECK_PROOF_SUBMISSIONS}}};
+
+  outcome::result<InvocationOutput> epochTick(const Actor &actor,
+                                              Runtime &runtime,
+                                              const MethodParams &params) {
+    if ((runtime.getMessage().get().from != kCronAddress)) {
+      return cron_actor::WRONG_CALL;
     }
 
     for (const auto &entry : entries) {
@@ -28,7 +26,7 @@ namespace fc::vm::actor {
     return outcome::success();
   }
 
-  ActorExports CronActor::exports = {
-      {kEpochTickMethodNumber, ActorMethod(CronActor::epochTick)},
+  ActorExports exports = {
+      {kEpochTickMethodNumber, ActorMethod(epochTick)},
   };
-}  // namespace fc::vm::actor
+}  // namespace fc::vm::actor::cron_actor

core/vm/actor/cron_actor.hpp

@@ -9,38 +9,28 @@
 #include "vm/actor/actor_method.hpp"
 #include "vm/actor/storage_power_actor.hpp"
 
-namespace fc::vm::actor {
-
-  using runtime::InvocationOutput;
-  using runtime::Runtime;
-
+namespace fc::vm::actor::cron_actor {
   struct CronTableEntry {
     Address to_addr;
     MethodNumber method_num{};
   };
 
-  struct CronActor {
-    static constexpr VMExitCode WRONG_CALL{1};
-
-    /**
-     * Entries is a set of actors (and corresponding methods) to call during
-     * EpochTick
-     */
-    static std::vector<CronTableEntry> entries;
-
-    /**
-     * @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
-     */
-    static outcome::result<InvocationOutput> epochTick(
-        const Actor &actor, Runtime &runtime, const MethodParams &params);
-
-    static ActorExports exports;
-  };
+  constexpr MethodNumber kEpochTickMethodNumber{2};
+  constexpr VMExitCode WRONG_CALL{1};
+
+  /**
+   * @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
+   */
+  outcome::result<InvocationOutput> epochTick(const Actor &actor,
+                                              Runtime &runtime,
+                                              const MethodParams &params);
+
+  extern ActorExports exports;
 
-}  // namespace fc::vm::actor
+}  // namespace fc::vm::actor::cron_actor
 
 #endif  // CPP_FILECOIN_CORE_VM_ACTOR_CRON_ACTOR_HPP

core/vm/actor/impl/invoker_impl.cpp

@@ -6,13 +6,15 @@
 #include "vm/actor/impl/invoker_impl.hpp"
 
 #include "vm/actor/cron_actor.hpp"
+#include "vm/actor/init_actor.hpp"
 
 namespace fc::vm::actor {
 
   using runtime::InvocationOutput;
 
   InvokerImpl::InvokerImpl() {
-    builtin_[actor::kCronCodeCid] = actor::CronActor::exports;
+    builtin_[actor::kCronCodeCid] = actor::cron_actor::exports;
+    builtin_[actor::kInitCodeCid] = actor::init_actor::exports;
   }
 
   outcome::result<InvocationOutput> InvokerImpl::invoke(

core/vm/actor/init_actor.cpp

@@ -7,8 +7,9 @@
 
 #include "primitives/address/address_codec.hpp"
 #include "storage/hamt/hamt.hpp"
+#include "vm/runtime/gas_cost.hpp"
 
-namespace fc::vm::actor {
+namespace fc::vm::actor::init_actor {
   outcome::result<Address> InitActorState::addActor(
       std::shared_ptr<IpfsDatastore> store, const Address &address) {
     storage::hamt::Hamt hamt(std::move(store), address_map);
@@ -19,4 +20,37 @@ namespace fc::vm::actor {
     ++next_id;
     return Address::makeFromId(id);
   }
-}  // namespace fc::vm::actor
+
+  outcome::result<InvocationOutput> exec(const Actor &actor,
+                                         Runtime &runtime,
+                                         const MethodParams &params) {
+    OUTCOME_TRY(exec_params, decodeActorParams<ExecParams>(params));
+    if (!isBuiltinActor(exec_params.code)) {
+      return init_actor::NOT_BUILTIN_ACTOR;
+    }
+    if (isSingletonActor(exec_params.code)) {
+      return init_actor::SINGLETON_ACTOR;
+    }
+    OUTCOME_TRY(runtime.chargeGas(runtime::kInitActorExecCost));
+    auto &message = runtime.getMessage().get();
+    auto actor_address{Address::makeActorExecAddress(
+        Buffer{primitives::address::encode(message.from)}.putUint64(
+            message.nonce))};
+    auto store = runtime.getIpfsDatastore();
+    OUTCOME_TRY(init_actor,
+                store->getCbor<InitActorState>(runtime.getCurrentActorState()));
+    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));
+    OUTCOME_TRY(new_state, store->setCbor(init_actor));
+    OUTCOME_TRY(runtime.commit(ActorSubstateCID{new_state}));
+    return InvocationOutput{Buffer{primitives::address::encode(id_address)}};
+  }
+
+  ActorExports exports{{kExecMethodNumber, ActorMethod(exec)}};
+}  // namespace fc::vm::actor::init_actor

core/vm/actor/init_actor.hpp

@@ -7,9 +7,9 @@
 #define CPP_FILECOIN_CORE_VM_ACTOR_INIT_ACTOR_HPP
 
 #include "storage/ipfs/datastore.hpp"
-#include "vm/actor/actor.hpp"
+#include "vm/actor/actor_method.hpp"
 
-namespace fc::vm::actor {
+namespace fc::vm::actor::init_actor {
   using storage::ipfs::IpfsDatastore;
 
   /// Init actor state
@@ -36,6 +36,36 @@ namespace fc::vm::actor {
     s.list() >> state.address_map >> state.next_id;
     return s;
   }
-}  // namespace fc::vm::actor
+
+  constexpr MethodNumber kExecMethodNumber{2};
+  constexpr VMExitCode NOT_BUILTIN_ACTOR{1};
+  constexpr VMExitCode SINGLETON_ACTOR{1};
+
+  struct ExecParams {
+    CodeId code;
+    MethodParams params;
+  };
+
+  outcome::result<InvocationOutput> exec(const Actor &actor,
+                                         Runtime &runtime,
+                                         const MethodParams &params);
+
+  extern ActorExports exports;
+
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference_t<Stream>::is_cbor_encoder_stream>>
+  Stream &operator<<(Stream &&s, const ExecParams &params) {
+    return s << (s.list() << params.code << params.params);
+  }
+
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference_t<Stream>::is_cbor_decoder_stream>>
+  Stream &operator>>(Stream &&s, ExecParams &params) {
+    s.list() >> params.code >> params.params;
+    return s;
+  }
+}  // namespace fc::vm::actor::init_actor
 
 #endif  // CPP_FILECOIN_CORE_VM_ACTOR_INIT_ACTOR_HPP

core/vm/runtime/gas_cost.hpp

@@ -105,6 +105,7 @@ namespace fc::vm::runtime {
    */
   inline static const BigInt kCommitGasCost{50};
 
+  inline static const BigInt kInitActorExecCost{100};
 }  // namespace fc::vm::runtime
 
 #endif  // CPP_FILECOIN_CORE_VM_RUNTIME_GAS_COST_HPP