strong types for runtime (#70)

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

Author: Alexey-N-Chernyshov

core/vm/actor/actor.cpp

@@ -16,14 +16,14 @@ namespace fc::vm::actor {
            && lhs.nonce == rhs.nonce && lhs.balance == rhs.balance;
   }
 
-  bool isBuiltinActor(const CID &code) {
+  bool isBuiltinActor(const CodeId &code) {
     return code == kStorageMarketCodeCid || code == kStoragePowerCodeCid
            || code == kStorageMinerCodeCid || code == kAccountCodeCid
            || code == kInitCodeCid || code == kMultisigCodeCid
            || code == kPaymentChannelCodeCid;
   }
 
-  bool isSingletonActor(const CID &code) {
+  bool isSingletonActor(const CodeId &code) {
     return code == kStoragePowerCodeCid || code == kStorageMarketCodeCid
            || code == kInitCodeCid || code == kCronCodeCid;
   }
@@ -44,12 +44,15 @@ namespace fc::vm::actor {
                 .value()};
   }
 
-  const CID kAccountCodeCid = makeRawIdentityCid("fil/1/account");
-  const CID kCronCodeCid = makeRawIdentityCid("fil/1/cron");
-  const CID kStoragePowerCodeCid = makeRawIdentityCid("fil/1/power");
-  const CID kStorageMarketCodeCid = makeRawIdentityCid("fil/1/market");
-  const CID kStorageMinerCodeCid = makeRawIdentityCid("fil/1/miner");
-  const CID kMultisigCodeCid = makeRawIdentityCid("fil/1/multisig");
-  const CID kInitCodeCid = makeRawIdentityCid("fil/1/init");
-  const CID kPaymentChannelCodeCid = makeRawIdentityCid("fil/1/paych");
+  const CodeId kAccountCodeCid = CodeId(makeRawIdentityCid("fil/1/account"));
+  const CodeId kCronCodeCid = CodeId(makeRawIdentityCid("fil/1/cron"));
+  const CodeId kStoragePowerCodeCid = CodeId(makeRawIdentityCid("fil/1/power"));
+  const CodeId kStorageMarketCodeCid =
+      CodeId(makeRawIdentityCid("fil/1/market"));
+  const CodeId kStorageMinerCodeCid = CodeId(makeRawIdentityCid("fil/1/miner"));
+  const CodeId kMultisigCodeCid = CodeId(makeRawIdentityCid("fil/1/multisig"));
+  const CodeId kInitCodeCid = CodeId(makeRawIdentityCid("fil/1/init"));
+  const CodeId kPaymentChannelCodeCid =
+      CodeId(makeRawIdentityCid("fil/1/paych"));
+
 }  // namespace fc::vm::actor

core/vm/actor/actor.hpp

@@ -6,21 +6,63 @@
 #ifndef CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_HPP
 #define CPP_FILECOIN_CORE_VM_ACTOR_ACTOR_HPP
 
-#include <libp2p/multi/content_identifier_codec.hpp>
-
+#include "common/buffer.hpp"
 #include "primitives/address/address.hpp"
 #include "primitives/big_int.hpp"
 #include "primitives/cid/cid.hpp"
 
 namespace fc::vm::actor {
-  using primitives::address::Address;
+
+  using fc::common::Buffer;
   using primitives::BigInt;
+  using primitives::address::Address;
+
+  /**
+   * Consider MethodNum numbers to be similar in concerns as for offsets in
+   * function tables (in programming languages), and for tags in ProtocolBuffer
+   * fields. Tags in ProtocolBuffers recommend assigning a unique tag to a field
+   * and never reusing that tag. If a field is no longer used, the field name
+   * may change but should still remain defined in the code to ensure the tag
+   * number is not reused accidentally. The same should apply to the MethodNum
+   * associated with methods in Filecoin VM Actors.
+   */
+  struct MethodNumber {
+    uint64_t method_number;
+  };
+
+  /**
+   * MethodParams is serialized parameters to the method call
+   */
+  class MethodParams : public Buffer {};
+
+  /**
+   * CodeID identifies an actor's code (either one of the builtin actors, or, in
+   * the future, potentially a CID of VM code for a custom actor)
+   */
+  class CodeId : public CID {
+   public:
+    CodeId() = default;
+    explicit CodeId(CID cid) : CID{std::move(cid)} {}
+  };
+
+  class ActorSubstateCID : public CID {
+   public:
+    ActorSubstateCID() = default;
+    explicit ActorSubstateCID(CID cid) : CID{std::move(cid)} {}
+  };
 
-  /** Common actor state interface */
+  /**
+   * Common actor state interface represents the on-chain storage all actors
+   * keep
+   */
   struct Actor {
-    CID code{};
-    CID head{};
+    /// Identifies the code this actor executes
+    CodeId code{};
+    /// CID of the root of optional actor-specific sub-state
+    ActorSubstateCID head{};
+    /// Expected sequence number of the next message sent by this actor
     uint64_t nonce{};
+    /// Balance of tokens held by this actor
     BigInt balance{};
   };
 
@@ -30,7 +72,8 @@ namespace fc::vm::actor {
             typename = std::enable_if_t<
                 std::remove_reference_t<Stream>::is_cbor_encoder_stream>>
   Stream &operator<<(Stream &&s, const Actor &actor) {
-    return s << (s.list() << actor.code << actor.head << actor.nonce << actor.balance);
+    return s << (s.list() << actor.code << actor.head << actor.nonce
+                          << actor.balance);
   }
 
   template <class Stream,
@@ -42,14 +85,14 @@ namespace fc::vm::actor {
   }
 
   /** Check if code specifies builtin actor implementation */
-  bool isBuiltinActor(const CID &code);
+  bool isBuiltinActor(const CodeId &code);
 
   /** Check if only one instance of actor should exists */
-  bool isSingletonActor(const CID &code);
+  bool isSingletonActor(const CodeId &code);
 
   extern const CID kEmptyObjectCid;
 
-  extern const CID kAccountCodeCid, kCronCodeCid, kStoragePowerCodeCid,
+  extern const CodeId kAccountCodeCid, kCronCodeCid, kStoragePowerCodeCid,
       kStorageMarketCodeCid, kStorageMinerCodeCid, kMultisigCodeCid,
       kInitCodeCid, kPaymentChannelCodeCid;
 

core/vm/state/state_tree.cpp

@@ -10,6 +10,7 @@
 #include "vm/actor/init_actor.hpp"
 
 namespace fc::vm::state {
+  using actor::ActorSubstateCID;
   using codec::cbor::decode;
   using primitives::address::encodeToString;
 
@@ -50,7 +51,7 @@ namespace fc::vm::state {
                 store_->getCbor<actor::InitActorState>(init_actor.head));
     OUTCOME_TRY(address_id, init_actor_state.addActor(store_, address));
     OUTCOME_TRY(init_actor_state_cid, store_->setCbor(init_actor_state));
-    init_actor.head = init_actor_state_cid;
+    init_actor.head = ActorSubstateCID{init_actor_state_cid};
     OUTCOME_TRY(set(actor::kInitAddress, init_actor));
     OUTCOME_TRY(set(address_id, actor));
     return std::move(address_id);

test/core/vm/actor/actor_test.cpp

@@ -14,20 +14,34 @@
  * @then Equal
  */
 TEST(ActorTest, CidGoCompatibility) {
-  EXPECT_EQ(fc::vm::actor::kAccountCodeCid, "0155000d66696c2f312f6163636f756e74"_cid);
+  EXPECT_EQ(fc::vm::actor::kAccountCodeCid,
+            "0155000d66696c2f312f6163636f756e74"_cid);
   EXPECT_EQ(fc::vm::actor::kCronCodeCid, "0155000a66696c2f312f63726f6e"_cid);
-  EXPECT_EQ(fc::vm::actor::kStoragePowerCodeCid, "0155000b66696c2f312f706f776572"_cid);
-  EXPECT_EQ(fc::vm::actor::kStorageMarketCodeCid, "0155000c66696c2f312f6d61726b6574"_cid);
-  EXPECT_EQ(fc::vm::actor::kStorageMinerCodeCid, "0155000b66696c2f312f6d696e6572"_cid);
-  EXPECT_EQ(fc::vm::actor::kMultisigCodeCid, "0155000e66696c2f312f6d756c7469736967"_cid);
+  EXPECT_EQ(fc::vm::actor::kStoragePowerCodeCid,
+            "0155000b66696c2f312f706f776572"_cid);
+  EXPECT_EQ(fc::vm::actor::kStorageMarketCodeCid,
+            "0155000c66696c2f312f6d61726b6574"_cid);
+  EXPECT_EQ(fc::vm::actor::kStorageMinerCodeCid,
+            "0155000b66696c2f312f6d696e6572"_cid);
+  EXPECT_EQ(fc::vm::actor::kMultisigCodeCid,
+            "0155000e66696c2f312f6d756c7469736967"_cid);
   EXPECT_EQ(fc::vm::actor::kInitCodeCid, "0155000a66696c2f312f696e6974"_cid);
-  EXPECT_EQ(fc::vm::actor::kPaymentChannelCodeCid, "0155000b66696c2f312f7061796368"_cid);
+  EXPECT_EQ(fc::vm::actor::kPaymentChannelCodeCid,
+            "0155000b66696c2f312f7061796368"_cid);
 
-  EXPECT_EQ(fc::vm::actor::kEmptyObjectCid, "01711220c19a797fa1fd590cd2e5b42d1cf5f246e29b91684e2f87404b81dc345c7a56a0"_cid);
+  EXPECT_EQ(
+      fc::vm::actor::kEmptyObjectCid,
+      "01711220c19a797fa1fd590cd2e5b42d1cf5f246e29b91684e2f87404b81dc345c7a56a0"_cid);
 }
 
 /** Actor CBOR encoding and decoding */
 TEST(ActorTest, ActorCbor) {
-  fc::vm::actor::Actor actor{fc::vm::actor::kAccountCodeCid, fc::vm::actor::kCronCodeCid, 3, 5};
-  expectEncodeAndReencode(actor, "84d82a52000155000d66696c2f312f6163636f756e74d82a4f000155000a66696c2f312f63726f6e03420005"_unhex);
+  fc::vm::actor::Actor actor{
+      fc::vm::actor::kAccountCodeCid,
+      fc::vm::actor::ActorSubstateCID{fc::vm::actor::kCronCodeCid},
+      3,
+      5};
+  expectEncodeAndReencode(
+      actor,
+      "84d82a52000155000d66696c2f312f6163636f756e74d82a4f000155000a66696c2f312f63726f6e03420005"_unhex);
 }

test/core/vm/actor/invoker_test.cpp

@@ -20,28 +20,34 @@ TEST(InvokerTest, InvokeCron) {
   Invoker invoker;
   fc::vm::MockVMContext vmc;
 
-  EXPECT_OUTCOME_ERROR(Invoker::CANT_INVOKE_ACCOUNT_ACTOR, invoker.invoke({kAccountCodeCid}, vmc, 0, {}));
-  EXPECT_OUTCOME_ERROR(Invoker::NO_CODE_OR_METHOD, invoker.invoke({kEmptyObjectCid}, vmc, 0, {}));
-  EXPECT_OUTCOME_ERROR(Invoker::NO_CODE_OR_METHOD, invoker.invoke({kCronCodeCid}, vmc, 1000, {}));
+  EXPECT_OUTCOME_ERROR(Invoker::CANT_INVOKE_ACCOUNT_ACTOR,
+                       invoker.invoke({kAccountCodeCid}, vmc, 0, {}));
+  EXPECT_OUTCOME_ERROR(Invoker::NO_CODE_OR_METHOD,
+                       invoker.invoke({CodeId{kEmptyObjectCid}}, vmc, 0, {}));
+  EXPECT_OUTCOME_ERROR(Invoker::NO_CODE_OR_METHOD,
+                       invoker.invoke({kCronCodeCid}, vmc, 1000, {}));
 
   EXPECT_CALL(vmc, message())
       .WillRepeatedly(testing::Return(fc::vm::Message{kInitAddress}));
-  EXPECT_OUTCOME_ERROR(CronActor::WRONG_CALL, invoker.invoke({kCronCodeCid}, vmc, 2, {}));
+  EXPECT_OUTCOME_ERROR(CronActor::WRONG_CALL,
+                       invoker.invoke({kCronCodeCid}, vmc, 2, {}));
 }
 
 /// decodeActorParams returns error or decoded params
 TEST(InvokerTest, DecodeActorParams) {
   using fc::vm::actor::decodeActorParams;
 
   // 80 is cbor empty list, not int
-  EXPECT_OUTCOME_ERROR(fc::vm::actor::DECODE_ACTOR_PARAMS_ERROR, decodeActorParams<int>("80"_unhex));
+  EXPECT_OUTCOME_ERROR(fc::vm::actor::DECODE_ACTOR_PARAMS_ERROR,
+                       decodeActorParams<int>("80"_unhex));
   EXPECT_OUTCOME_EQ(decodeActorParams<int>("03"_unhex), 3);
 }
 
 /// encodeActorParams returns error or encoded params
 TEST(InvokerTest, EncodeActorParams) {
   using fc::vm::actor::encodeActorParams;
 
-  EXPECT_OUTCOME_ERROR(fc::vm::actor::ENCODE_ACTOR_PARAMS_ERROR, encodeActorParams(fc::CID()));
+  EXPECT_OUTCOME_ERROR(fc::vm::actor::ENCODE_ACTOR_PARAMS_ERROR,
+                       encodeActorParams(fc::CID()));
   EXPECT_OUTCOME_EQ(encodeActorParams(3), "03"_unhex);
 }

test/core/vm/state/state_tree_test.cpp

@@ -17,10 +17,15 @@ using fc::primitives::address::Address;
 using fc::storage::hamt::Hamt;
 using fc::storage::hamt::HamtError;
 using fc::vm::actor::Actor;
+using fc::vm::actor::ActorSubstateCID;
+using fc::vm::actor::CodeId;
 using fc::vm::state::StateTree;
 
 auto kAddressId = Address::makeFromId(13);
-const Actor kActor{"010001020001"_cid, "010001020002"_cid, 3, BigInt(5)};
+const Actor kActor{CodeId{"010001020001"_cid},
+                   ActorSubstateCID{"010001020002"_cid},
+                   3,
+                   BigInt(5)};
 
 class StateTreeTest : public ::testing::Test {
  public:
@@ -74,7 +79,10 @@ TEST_F(StateTreeTest, RegisterNewAddressLookupId) {
   EXPECT_OUTCOME_TRUE(empty_map, Hamt(store_).flush());
   InitActorState init_actor_state{empty_map, 13};
   EXPECT_OUTCOME_TRUE(init_actor_state_cid, store_->setCbor(init_actor_state));
-  Actor init_actor{"010001020000"_cid, init_actor_state_cid, {}, {}};
+  Actor init_actor{CodeId{"010001020000"_cid},
+                   ActorSubstateCID{init_actor_state_cid},
+                   {},
+                   {}};
   EXPECT_OUTCOME_TRUE_1(tree_.set(kInitAddress, init_actor));
   Address address{fc::primitives::address::TESTNET,
                   fc::primitives::address::ActorExecHash{}};