Feature/runtime (#65)

Signed-off-by: Alexey-N-Chernyshov <[email protected]>

Author: Alexey-N-Chernyshov

core/primitives/address/address.cpp

@@ -53,6 +53,10 @@ namespace fc::primitives::address {
            && lhs.data == rhs.data;
   }
 
+  bool operator!=(const Address &lhs, const Address &rhs) {
+    return !(lhs == rhs);
+  }
+
   bool operator<(const Address &lhs, const Address &rhs) {
     return lhs.network < rhs.network
            || (lhs.network == rhs.network

core/primitives/address/address.hpp

@@ -77,6 +77,11 @@ namespace fc::primitives::address {
    */
   bool operator==(const Address &lhs, const Address &rhs);
 
+  /**
+   * @brief Addresses not equality operator
+   */
+  bool operator!=(const Address &lhs, const Address &rhs);
+
   /**
    * @brief Addresses "less than" operator
    */

core/primitives/big_int.hpp

@@ -21,6 +21,14 @@ namespace fc::primitives {
     using cpp_int::cpp_int;
   };
 
+  static inline BigInt operator*(const BigInt &lhs, const BigInt &rhs) {
+    return static_cast<cpp_int>(lhs) * static_cast<cpp_int>(rhs);
+  }
+
+  static inline BigInt operator*(const unsigned long &lhs, const BigInt &rhs) {
+    return static_cast<cpp_int>(lhs) * static_cast<cpp_int>(rhs);
+  }
+
   static inline BigInt operator+(const BigInt &lhs, const BigInt &rhs) {
     return static_cast<cpp_int>(lhs) + static_cast<cpp_int>(rhs);
   }

core/vm/CMakeLists.txt

@@ -5,5 +5,7 @@
 
 add_subdirectory(actor)
 add_subdirectory(exit_code)
+add_subdirectory(indices)
+add_subdirectory(runtime)
 add_subdirectory(state)
 add_subdirectory(message)

core/vm/actor/CMakeLists.txt

@@ -8,10 +8,9 @@ add_library(actor
     actor.cpp
     init_actor.cpp
     cron_actor.cpp
+    impl/invoker_impl.cpp
     storage_power_actor.cpp
-    invoker.cpp
     )
-
 target_link_libraries(actor
     address
     cid

core/vm/actor/actor.cpp

@@ -11,6 +11,7 @@
 #include <libp2p/crypto/sha/sha256.hpp>
 
 namespace fc::vm::actor {
+
   bool operator==(const Actor &lhs, const Actor &rhs) {
     return lhs.code == rhs.code && lhs.head == rhs.head
            && lhs.nonce == rhs.nonce && lhs.balance == rhs.balance;

core/vm/actor/actor.hpp

@@ -32,6 +32,10 @@ namespace fc::vm::actor {
     inline bool operator==(const MethodNumber &other) const {
       return method_number == other.method_number;
     }
+
+    inline bool operator<(const MethodNumber &other) const {
+      return method_number < other.method_number;
+    }
   };
 
   template <class Stream,

core/vm/actor/actor_method.hpp

@@ -7,21 +7,21 @@
 #define CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_METHOD_HPP
 
 #include "codec/cbor/cbor.hpp"
-#include "common/buffer.hpp"
 #include "common/outcome.hpp"
 #include "vm/actor/actor.hpp"
 #include "vm/exit_code/exit_code.hpp"
-#include "vm/vm_context.hpp"
+#include "vm/runtime/runtime.hpp"
 
 namespace fc::vm::actor {
-  using common::Buffer;
+  using runtime::InvocationOutput;
+  using runtime::Runtime;
 
   /// Actor method signature
-  using ActorMethod = std::function<outcome::result<Buffer>(
-      const Actor &, VMContext &, gsl::span<const uint8_t>)>;
+  using ActorMethod = std::function<outcome::result<InvocationOutput>(
+      const Actor &, Runtime &, const MethodParams &)>;
 
   /// Actor methods exported by number
-  using ActorExports = std::map<uint64_t, ActorMethod>;
+  using ActorExports = std::map<MethodNumber, ActorMethod>;
 
   constexpr VMExitCode DECODE_ACTOR_PARAMS_ERROR{1};
 

core/vm/actor/cron_actor.cpp

@@ -6,24 +6,29 @@
 #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<Buffer> CronActor::epochTick(
-      const Actor &actor,
-      vm::VMContext &vmctx,
-      gsl::span<const uint8_t> params) {
-    if (!(vmctx.message().from == kCronAddress)) {
+  outcome::result<InvocationOutput> CronActor::epochTick(
+      const Actor &actor, Runtime &runtime, const MethodParams &params) {
+    if ((runtime.getMessage()->from != kCronAddress)) {
       return WRONG_CALL;
     }
 
     for (const auto &entry : entries) {
-      OUTCOME_TRY(vmctx.send(entry.to_addr, entry.method_num, BigInt(0), {}));
+      OUTCOME_TRY(runtime.send(entry.to_addr, entry.method_num, {}, BigInt(0)));
     }
     return outcome::success();
   }
 
   ActorExports CronActor::exports = {
-      {2, ActorMethod(CronActor::epochTick)},
+      {kEpochTickMethodNumber, ActorMethod(CronActor::epochTick)},
   };
 }  // namespace fc::vm::actor

core/vm/actor/cron_actor.hpp

@@ -11,9 +11,12 @@
 
 namespace fc::vm::actor {
 
+  using runtime::InvocationOutput;
+  using runtime::Runtime;
+
   struct CronTableEntry {
     Address to_addr;
-    uint64_t method_num{};
+    MethodNumber method_num{};
   };
 
   struct CronActor {
@@ -28,13 +31,12 @@ namespace fc::vm::actor {
     /**
      * @brief EpochTick executes built-in periodic actions, run at every Epoch.
      * @param actor from Lotus(doesn't use)
-     * @param vmctx is virtual machine context
+     * @param runtime is virtual machine context
      * @param params from Lotus(doesn't use)
      * @return success or error
      */
-    static outcome::result<Buffer> epochTick(const Actor &actor,
-                                             VMContext &vmctx,
-                                             gsl::span<const uint8_t> params);
+    static outcome::result<InvocationOutput> epochTick(
+        const Actor &actor, Runtime &runtime, const MethodParams &params);
 
     static ActorExports exports;
   };