Small refactoring 2 (#157)

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

Author: turuslan

core/api/make.cpp

@@ -160,8 +160,7 @@ namespace fc::api {
           result.message = message;
           auto maybe_result = env.applyImplicitMessage(message);
           if (maybe_result) {
-            result.receipt = {
-                VMExitCode::Ok, maybe_result.value().return_value, 0};
+            result.receipt = {VMExitCode::Ok, maybe_result.value(), 0};
           } else {
             if (isVMExitCode(maybe_result.error())) {
               auto ret_code =

core/codec/cbor/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(cbor
     cbor_resolve.cpp
     )
 target_link_libraries(cbor
+    buffer
     cid
     outcome
     tinycbor

core/codec/cbor/cbor.hpp

@@ -9,20 +9,23 @@
 #include "codec/cbor/cbor_decode_stream.hpp"
 #include "codec/cbor/cbor_encode_stream.hpp"
 #include "codec/cbor/cbor_resolve.hpp"
+#include "common/buffer.hpp"
 
 namespace fc::codec::cbor {
+  using common::Buffer;
+
   /**
    * @brief CBOR encoding to byte-vector
    * @tparam Type to be encoded
    * @param arg data to be encoded
    * @return encoded data
    */
   template <typename T>
-  outcome::result<std::vector<uint8_t>> encode(const T &arg) {
+  outcome::result<Buffer> encode(const T &arg) {
     try {
       CborEncodeStream encoder;
       encoder << arg;
-      return encoder.data();
+      return Buffer{encoder.data()};
     } catch (std::system_error &e) {
       return outcome::failure(e.code());
     }

core/storage/chain/impl/chain_store_impl.cpp

@@ -116,8 +116,7 @@ namespace fc::storage::blockchain {
     for (auto &b : block_headers) {
       OUTCOME_TRY(data, codec::cbor::encode(b));
       OUTCOME_TRY(cid, common::getCidOf(data));
-      OUTCOME_TRY(
-          block_service_->set(std::move(cid), common::Buffer{std::move(data)}));
+      OUTCOME_TRY(block_service_->set(std::move(cid), std::move(data)));
     }
 
     return outcome::success();

core/storage/ipld/ipld_block.hpp

@@ -76,7 +76,7 @@ namespace fc::storage::ipld {
     static common::Buffer serialize(const T &entity) {
       auto data = codec::cbor::encode(entity);
       BOOST_ASSERT(data.has_value());
-      return common::Buffer{std::move(data.value())};
+      return std::move(data.value());
     }
   };
 }  // namespace fc::storage::ipld

core/vm/actor/actor_encoding.hpp

@@ -52,13 +52,16 @@ namespace fc::vm::actor {
     if constexpr (std::is_same_v<T, None>) {
       return T{};
     }
-    return codec::cbor::decode<T>(result.return_value);
+    return codec::cbor::decode<T>(result);
   }
 
   template <typename T>
   outcome::result<InvocationOutput> encodeActorReturn(const T &result) {
-    OUTCOME_TRY(encoded, codec::cbor::encode(result));
-    return InvocationOutput{Buffer{encoded}};
+    auto maybe_encoded = codec::cbor::encode(result);
+    if (!maybe_encoded) {
+      return VMExitCode::ENCODE_ACTOR_RESULT_ERROR;
+    }
+    return std::move(maybe_encoded.value());
   }
 }  // namespace fc::vm::actor
 

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

@@ -8,35 +8,13 @@
 #include "vm/exit_code/exit_code.hpp"
 
 namespace fc::vm::actor::builtin::account {
-
-  outcome::result<Actor> AccountActor::create(
-      const std::shared_ptr<StateTree> &state_tree, const Address &address) {
-    if (!address.isKeyType()) {
+  ACTOR_METHOD_IMPL(Construct) {
+    OUTCOME_TRY(runtime.validateImmediateCallerIs(kSystemActorAddress));
+    if (!params.isKeyType()) {
       return VMExitCode::ACCOUNT_ACTOR_CREATE_WRONG_ADDRESS_TYPE;
     }
-    OUTCOME_TRY(state,
-                state_tree->getStore()->setCbor(AccountActorState{address}));
-    Actor actor{kAccountCodeCid, ActorSubstateCID{state}, 0, 0};
-    OUTCOME_TRY(state_tree->registerNewAddress(address, actor));
-    return actor;
-  }
-
-  outcome::result<Address> AccountActor::resolveToKeyAddress(
-      const std::shared_ptr<StateTree> &state_tree, const Address &address) {
-    if (address.isKeyType()) {
-      return address;
-    }
-    auto maybe_actor = state_tree->get(address);
-    if (!maybe_actor) {
-      return VMExitCode::ACCOUNT_ACTOR_RESOLVE_NOT_FOUND;
-    }
-    auto actor = maybe_actor.value();
-    if (actor.code != kAccountCodeCid) {
-      return VMExitCode::ACCOUNT_ACTOR_RESOLVE_NOT_ACCOUNT_ACTOR;
-    }
-    OUTCOME_TRY(account_actor_state,
-                state_tree->getStore()->getCbor<AccountActorState>(actor.head));
-    return account_actor_state.address;
+    OUTCOME_TRY(runtime.commitState(AccountActorState{params}));
+    return outcome::success();
   }
 
   ACTOR_METHOD_IMPL(PubkeyAddress) {
@@ -45,6 +23,7 @@ namespace fc::vm::actor::builtin::account {
   }
 
   const ActorExports exports{
+      exportMethod<Construct>(),
       exportMethod<PubkeyAddress>(),
   };
 }  // namespace fc::vm::actor::builtin::account

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

@@ -22,19 +22,9 @@ namespace fc::vm::actor::builtin::account {
   };
   CBOR_TUPLE(AccountActorState, address)
 
-  /// Account actors represent actors without code
-  struct AccountActor {
-    /// Create account actor from BLS or Secp256k1 address
-    static outcome::result<Actor> create(
-        const std::shared_ptr<StateTree> &state_tree, const Address &address);
-    /**
-     * Get BLS address of account actor from ID address
-     * @param state_tree state tree
-     * @param address id address to be resolved to key address
-     * @returns key address associated with id address
-     */
-    static outcome::result<Address> resolveToKeyAddress(
-        const std::shared_ptr<StateTree> &state_tree, const Address &address);
+  struct Construct : ActorMethodBase<1> {
+    using Params = Address;
+    ACTOR_METHOD_DECL();
   };
 
   struct PubkeyAddress : ActorMethodBase<2> {

core/vm/actor/builtin/miner/miner_actor.cpp

@@ -92,7 +92,7 @@ namespace fc::vm::actor::builtin::miner {
         kStoragePowerAddress,
         {
             .event_epoch = event_epoch,
-            .payload = Buffer{payload2},
+            .payload = payload2,
         },
         0));
     return outcome::success();
@@ -148,7 +148,7 @@ namespace fc::vm::actor::builtin::miner {
                     .randomness = runtime.getRandomness(
                         DomainSeparationTag::PoStDST,
                         state.post_state.proving_period_start,
-                        Buffer{seed}),
+                        seed),
                     .candidates = params.candidates,
                     .proofs = params.proofs,
                     .eligible_sectors = sectors,

core/vm/exit_code/exit_code.hpp

@@ -42,6 +42,9 @@ namespace fc::vm {
     ErrPlaceholder = 1000,
 
     DECODE_ACTOR_PARAMS_ERROR,
+    ENCODE_ACTOR_RESULT_ERROR,
+
+    SEND_TRANSFER_INSUFFICIENT,
 
     ACCOUNT_ACTOR_CREATE_WRONG_ADDRESS_TYPE,
     ACCOUNT_ACTOR_RESOLVE_NOT_FOUND,

core/vm/exit_code/impl/exit_code.cpp

@@ -54,6 +54,11 @@ namespace fc::vm {
 
       case E::DECODE_ACTOR_PARAMS_ERROR:
         return E{1};
+      case E::ENCODE_ACTOR_RESULT_ERROR:
+        return E{2};
+
+      case E::SEND_TRANSFER_INSUFFICIENT:
+        return E{1};
 
       case E::ACCOUNT_ACTOR_CREATE_WRONG_ADDRESS_TYPE:
         return E::ErrIllegalArgument;

core/vm/runtime/env.hpp

@@ -31,22 +31,33 @@ namespace fc::vm::runtime {
                                                  TokenAmount &penalty);
 
     outcome::result<InvocationOutput> applyImplicitMessage(
-        UnsignedMessage message) {
-      OUTCOME_TRY(from, state_tree->get(message.from));
-      message.nonce = from.nonce;
-      GasAmount gas_used{0};
-      return send(gas_used, message.from, message);
-    }
-
-    outcome::result<InvocationOutput> send(GasAmount &gas_used,
-                                           const Address &origin,
-                                           const UnsignedMessage &message);
+        UnsignedMessage message);
 
     std::shared_ptr<RandomnessProvider> randomness_provider;
     std::shared_ptr<StateTree> state_tree;
     std::shared_ptr<Invoker> invoker;
     ChainEpoch chain_epoch;
   };
+
+  struct Execution : std::enable_shared_from_this<Execution> {
+    static std::shared_ptr<Execution> make(std::shared_ptr<Env> env,
+                                           const UnsignedMessage &message);
+
+    outcome::result<void> chargeGas(GasAmount amount);
+
+    outcome::result<Actor> tryCreateAccountActor(const Address &address);
+
+    outcome::result<InvocationOutput> sendWithRevert(
+        const UnsignedMessage &message);
+
+    outcome::result<InvocationOutput> send(const UnsignedMessage &message);
+
+    std::shared_ptr<Env> env;
+    std::shared_ptr<StateTree> state_tree;
+    GasAmount gas_used;
+    GasAmount gas_limit;
+    Address origin;
+  };
 }  // namespace fc::vm::runtime
 
 #endif  // FILECOIN_CORE_VM_RUNTIME_ENV_HPP

core/vm/runtime/gas_cost.hpp

@@ -26,10 +26,11 @@ namespace fc::vm::runtime {
    * up to but excluding any actual processing by the VM.
    * This is the cost a block producer burns when including an invalid message.
    */
-  inline static const GasAmount kOnChainMessageBaseGasCost{
-      kGasAmountPlaceholder};
+  inline static const GasAmount kOnChainMessageBaseGasCost{0};
   inline static const GasAmount kOnChainMessagePerByteGasCharge{2};
 
+  inline static const GasAmount kOnChainReturnValuePerByteCost{8};
+
   /**
    * Gas cost charged to the originator of a non-nil return value produced by an
    * on-chain message is given by:
@@ -52,14 +53,14 @@ namespace fc::vm::runtime {
    * by any nonzero currency amount. Accounts for writing receiver's new balance
    * (the sender's state is already accounted for).
    */
-  inline static const GasAmount kSendTransferFundsGasCost{10};
+  inline static const GasAmount kSendTransferFundsGasCost{5};
 
   /**
    * Gas cost charged, in addition to SendBase, if a message invokes a method on
    * the receiver. Accounts for the cost of loading receiver code and method
    * dispatch.
    */
-  inline static const GasAmount kSendInvokeMethodGasCost{5};
+  inline static const GasAmount kSendInvokeMethodGasCost{10};
 
   /**
    * Gas cost (Base + len * PerByte) for any Get operation to the IPLD store in
@@ -89,7 +90,7 @@ namespace fc::vm::runtime {
    * Gas cost for creating a new actor (via InitActor's Exec method). Actor
    * sub-state is charged separately.
    */
-  inline static const GasAmount kExecNewActorGasCost{kGasAmountPlaceholder};
+  inline static const GasAmount kCreateActorGasCost{40 + 500};
 
   /**
    * Gas cost for deleting an actor.