Small refactoring (#156)

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

Author: turuslan

core/adt/array.hpp

@@ -53,6 +53,11 @@ namespace fc::adt {
       return amt.remove(key);
     }
 
+    outcome::result<void> append(const Value &value) {
+      OUTCOME_TRY(count, amt.count());
+      return set(count, value);
+    }
+
     outcome::result<void> flush() {
       OUTCOME_TRY(amt.flush());
       return outcome::success();

core/adt/empty_value.hpp

@@ -21,8 +21,7 @@ namespace fc::adt {
         array = Array<Value>{};
       }
       array->load(map.hamt.getIpld());
-      OUTCOME_TRY(count, array->amt.count());
-      OUTCOME_TRY(array->set(count, value));
+      OUTCOME_TRY(array->append(value));
       OUTCOME_TRY(array->flush());
       return map.set(key, *array);
     }

core/adt/multimap.hpp

@@ -0,0 +1,25 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_ADT_SET_HPP
+#define CPP_FILECOIN_ADT_SET_HPP
+
+#include "adt/map.hpp"
+
+namespace fc::adt {
+  struct SetValue {};
+  CBOR_ENCODE(SetValue, v) {
+    return s << nullptr;
+  }
+  CBOR_DECODE(SetValue, v) {
+    s.next();
+    return s;
+  }
+
+  template <typename Keyer>
+  struct Set : Map<SetValue, Keyer> {};
+}  // namespace fc::adt
+
+#endif  // CPP_FILECOIN_ADT_SET_HPP

core/adt/set.hpp

@@ -8,6 +8,7 @@ add_library(api
     )
 target_link_libraries(api
     address
+    block_producer
     chain_store
     cid
     interpreter

core/api/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 #include "api/make.hpp"
 
+#include "blockchain/production/impl/block_producer_impl.hpp"
 #include "vm/actor/builtin/market/actor.hpp"
 #include "vm/actor/builtin/miner/types.hpp"
 #include "vm/actor/builtin/storage_power/storage_power_actor_state.hpp"
@@ -19,21 +20,24 @@ namespace fc::api {
   using vm::actor::builtin::miner::MinerActorState;
   using vm::actor::builtin::storage_power::StoragePowerActorState;
   using vm::interpreter::InterpreterImpl;
+  using InterpreterResult = vm::interpreter::Result;
   using vm::state::StateTreeImpl;
   using MarketActorState = vm::actor::builtin::market::State;
+  using blockchain::production::BlockProducerImpl;
   using crypto::randomness::RandomnessProvider;
   using crypto::signature::BlsSignature;
   using primitives::block::MsgMeta;
   using storage::amt::Amt;
+  using vm::isVMExitCode;
+  using vm::normalizeVMExitCode;
   using vm::VMExitCode;
   using vm::actor::InvokerImpl;
-  using vm::indices::Indices;
   using vm::runtime::Env;
 
   struct TipsetContext {
     Tipset tipset;
     StateTreeImpl state_tree;
-    boost::optional<CID> receipts;
+    boost::optional<InterpreterResult> interpreted;
 
     template <typename T, bool load>
     outcome::result<T> actorState(const Address &address) {
@@ -70,10 +74,9 @@ namespace fc::api {
       OUTCOME_TRY(tipset, chain_store->loadTipset(tipset_key));
       TipsetContext context{tipset, {ipld, tipset.getParentStateRoot()}, {}};
       if (interpret) {
-        // TODO(turuslan): our Indices are not used anywhere
-        OUTCOME_TRY(result, InterpreterImpl{}.interpret(ipld, tipset, nullptr));
+        OUTCOME_TRY(result, InterpreterImpl{}.interpret(ipld, tipset));
         context.state_tree = {ipld, result.state_root};
-        context.receipts = result.message_receipts;
+        context.interpreted = result;
       }
       return context;
     };
@@ -100,59 +103,43 @@ namespace fc::api {
                                  auto height,
                                  auto timestamp) -> outcome::result<BlockMsg> {
           OUTCOME_TRY(context, tipsetContext(parent, true));
+          BlockProducerImpl producer{
+              ipld,
+              nullptr,
+              nullptr,
+              nullptr,
+              weight_calculator,
+              bls_provider,
+              std::make_shared<InterpreterImpl>(),
+          };
+          OUTCOME_TRY(block,
+                      producer.generate(miner,
+                                        context.tipset,
+                                        *context.interpreted,
+                                        proof,
+                                        ticket,
+                                        messages,
+                                        height,
+                                        timestamp));
 
           OUTCOME_TRY(miner_state, context.minerState(miner));
           OUTCOME_TRY(worker_id,
                       context.state_tree.lookupId(miner_state.info.worker));
-          OUTCOME_TRY(state_root, context.state_tree.flush());
-
-          BlockMsg block;
-          block.header.miner = miner;
-          block.header.parents = parent.cids;
-          block.header.ticket = ticket;
-          block.header.height = height;
-          block.header.timestamp = timestamp;
-          block.header.epost_proof = proof;
-          block.header.parent_state_root = state_root;
-          block.header.parent_message_receipts = *context.receipts;
-          block.header.fork_signaling = 0;
-
-          std::vector<BlsSignature> bls_sigs;
-          Amt amt_bls{ipld}, amt_secp{ipld};
-          uint64_t i_bls{0}, i_secp{0};
-          for (auto &message : messages) {
-            if (message.signature.isBls()) {
-              OUTCOME_TRY(message_cid, ipld->setCbor(message.message));
-              bls_sigs.emplace_back(
-                  boost::get<BlsSignature>(message.signature));
-              block.bls_messages.emplace_back(std::move(message_cid));
-              OUTCOME_TRY(amt_bls.setCbor(++i_bls, message_cid));
-            } else {
-              OUTCOME_TRY(message_cid, ipld->setCbor(message));
-              block.secp_messages.emplace_back(std::move(message_cid));
-              OUTCOME_TRY(amt_secp.setCbor(++i_secp, message_cid));
-            }
-          }
-
-          OUTCOME_TRY(amt_bls.flush());
-          OUTCOME_TRY(amt_secp.flush());
-          OUTCOME_TRY(msg_meta,
-                      ipld->setCbor(MsgMeta{amt_bls.cid(), amt_secp.cid()}));
-          block.header.messages = msg_meta;
-
-          OUTCOME_TRY(bls_aggregate,
-                      bls_provider->aggregateSignatures(bls_sigs));
-          block.header.bls_aggregate = bls_aggregate;
-
-          OUTCOME_TRY(parent_weight,
-                      weight_calculator->calculateWeight(context.tipset));
-          block.header.parent_weight = parent_weight;
-
           OUTCOME_TRY(block_signable, codec::cbor::encode(block.header));
           OUTCOME_TRY(block_sig, key_store->sign(worker_id, block_signable));
           block.header.block_sig = block_sig;
 
-          return block;
+          BlockMsg block2;
+          block2.header = block.header;
+          for (auto &msg : block.bls_messages) {
+            OUTCOME_TRY(cid, ipld->setCbor(msg));
+            block2.bls_messages.emplace_back(std::move(cid));
+          }
+          for (auto &msg : block.secp_messages) {
+            OUTCOME_TRY(cid, ipld->setCbor(msg));
+            block2.secp_messages.emplace_back(std::move(cid));
+          }
+          return block2;
         }},
         // TODO(turuslan): FIL-165 implement method
         .MpoolPending = {},
@@ -163,20 +150,29 @@ namespace fc::api {
         .StateCall = {[&](auto &message,
                           auto &tipset_key) -> outcome::result<InvocResult> {
           OUTCOME_TRY(context, tipsetContext(tipset_key));
-          // TODO(turuslan): our Indices are not used anywhere
-          std::shared_ptr<Indices> indices;
           // TODO(turuslan): FIL-146 randomness from tipset
           std::shared_ptr<RandomnessProvider> randomness;
           Env env{randomness,
                   std::make_shared<StateTreeImpl>(context.state_tree),
-                  indices,
                   std::make_shared<InvokerImpl>(),
-                  static_cast<ChainEpoch>(context.tipset.height),
-                  Address{}};
-          OUTCOME_TRY(receipt, env.applyMessage(message));
+                  static_cast<ChainEpoch>(context.tipset.height)};
           InvocResult result;
           result.message = message;
-          result.receipt = receipt;
+          auto maybe_result = env.applyImplicitMessage(message);
+          if (maybe_result) {
+            result.receipt = {
+                VMExitCode::Ok, maybe_result.value().return_value, 0};
+          } else {
+            if (isVMExitCode(maybe_result.error())) {
+              auto ret_code =
+                  normalizeVMExitCode(VMExitCode{maybe_result.error().value()});
+              BOOST_ASSERT_MSG(ret_code,
+                               "c++ actor code returned unknown error");
+              result.receipt = {*ret_code, {}, 0};
+            } else {
+              return maybe_result.error();
+            }
+          }
           return result;
         }},
         .StateGetActor = {[&](auto &address,

core/api/make.cpp

@@ -373,16 +373,14 @@ namespace fc::api {
 
     ENCODE(MessageReceipt) {
       Value j{rapidjson::kObjectType};
-      Set(j, "ExitCode", static_cast<uint64_t>(v.exit_code));
+      Set(j, "ExitCode", common::to_int(v.exit_code));
       Set(j, "Return", gsl::make_span(v.return_value));
       Set(j, "GasUsed", v.gas_used);
       return j;
     }
 
     DECODE(MessageReceipt) {
-      uint64_t exit_code;
-      decode(exit_code, Get(j, "ExitCode"));
-      v.exit_code = exit_code;
+      decodeEnum(v.exit_code, Get(j, "ExitCode"));
       decode(v.return_value, Get(j, "Return"));
       decode(v.gas_used, Get(j, "GasUsed"));
     }

core/api/rpc/json.hpp

@@ -14,7 +14,6 @@
 namespace fc::blockchain::block_validator {
   using primitives::address::Protocol;
   using storage::amt::Amt;
-  using MsgMeta = primitives::block::MsgMeta;
   using SignedMessage = vm::message::SignedMessage;
   using UnsignedMessage = vm::message::UnsignedMessage;
   using BlsCryptoSignature = crypto::bls::Signature;
@@ -141,9 +140,7 @@ namespace fc::blockchain::block_validator {
   outcome::result<void> BlockValidatorImpl::stateTree(
       const BlockHeader &block) const {
     OUTCOME_TRY(parent_tipset, getParentTipset(block));
-    OUTCOME_TRY(
-        result,
-        vm_interpreter_->interpret(datastore_, parent_tipset, vm_indices_));
+    OUTCOME_TRY(result, vm_interpreter_->interpret(datastore_, parent_tipset));
     if (result.state_root == block.parent_state_root
         && result.message_receipts == block.parent_message_receipts) {
       return outcome::success();
@@ -174,7 +171,8 @@ namespace fc::blockchain::block_validator {
       }
     }
     OUTCOME_TRY(tipset, Tipset::create(parent_blocks));
-    parent_tipset_cache_ = std::make_pair(std::move(ipld_block.cid), std::move(tipset));
+    parent_tipset_cache_ =
+        std::make_pair(std::move(ipld_block.cid), std::move(tipset));
     return parent_tipset_cache_.value().second;
   }
 

core/blockchain/block_validator/impl/block_validator_impl.cpp

@@ -19,7 +19,6 @@
 #include "crypto/bls/bls_provider.hpp"
 #include "power/power_table.hpp"
 #include "storage/ipfs/datastore.hpp"
-#include "vm/indices/indices.hpp"
 #include "vm/interpreter/interpreter.hpp"
 
 namespace fc::blockchain::block_validator {
@@ -36,7 +35,6 @@ namespace fc::blockchain::block_validator {
     using SecpProvider = libp2p::crypto::secp256k1::Secp256k1Provider;
     using Interpreter = vm::interpreter::Interpreter;
     using Tipset = primitives::tipset::Tipset;
-    using Indices = vm::indices::Indices;
 
    public:
     using StageExecutor = outcome::result<void> (BlockValidatorImpl::*)(
@@ -49,17 +47,15 @@ namespace fc::blockchain::block_validator {
                        std::shared_ptr<PowerTable> power_table,
                        std::shared_ptr<BlsProvider> bls_crypto_provider,
                        std::shared_ptr<SecpProvider> secp_crypto_provider,
-                       std::shared_ptr<Interpreter> vm_interpreter,
-                       std::shared_ptr<Indices> indices)
+                       std::shared_ptr<Interpreter> vm_interpreter)
         : datastore_{std::move(ipfs_store)},
           clock_{std::move(utc_clock)},
           epoch_clock_{std::move(epoch_clock)},
           weight_calculator_{std::move(weight_calculator)},
           power_table_{std::move(power_table)},
           bls_provider_{std::move(bls_crypto_provider)},
           secp_provider_{std::move(secp_crypto_provider)},
-          vm_interpreter_{std::move(vm_interpreter)},
-          vm_indices_{std::move(indices)} {}
+          vm_interpreter_{std::move(vm_interpreter)} {}
 
     outcome::result<void> validateBlock(
         const BlockHeader &header, scenarios::Scenario scenario) const override;
@@ -75,7 +71,6 @@ namespace fc::blockchain::block_validator {
     std::shared_ptr<BlsProvider> bls_provider_;
     std::shared_ptr<SecpProvider> secp_provider_;
     std::shared_ptr<Interpreter> vm_interpreter_;
-    std::shared_ptr<Indices> vm_indices_;
 
     /**
      * BlockHeader CID -> Parent tipset

core/blockchain/block_validator/impl/block_validator_impl.hpp

@@ -8,7 +8,6 @@
 #include "primitives/block/block.hpp"
 #include "primitives/ticket/epost_ticket.hpp"
 #include "primitives/ticket/ticket.hpp"
-#include "vm/indices/indices.hpp"
 
 namespace fc::blockchain::production {
   /**
@@ -20,7 +19,6 @@ namespace fc::blockchain::production {
     using Address = primitives::address::Address;
     using EPostProof = primitives::ticket::EPostProof;
     using Ticket = primitives::ticket::Ticket;
-    using Indices = vm::indices::Indices;
 
    public:
     virtual ~BlockProducer() = default;
@@ -33,12 +31,10 @@ namespace fc::blockchain::production {
      * @param ticket - used ticket for election round
      * @return Generated full block
      */
-    virtual outcome::result<Block> generate(
-        Address miner_address,
-        const CID &parent_tipset_id,
-        EPostProof proof,
-        Ticket ticket,
-        std::shared_ptr<Indices> indices) = 0;
+    virtual outcome::result<Block> generate(Address miner_address,
+                                            const CID &parent_tipset_id,
+                                            EPostProof proof,
+                                            Ticket ticket) = 0;
   };
 
   /**