Update block (#206)

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

Author: turuslan

core/api/api.hpp

@@ -59,6 +59,7 @@ namespace fc::api {
   using primitives::address::Address;
   using primitives::block::BlockHeader;
   using primitives::block::BlockMsg;
+  using primitives::block::BlockTemplate;
   using primitives::ticket::EPostProof;
   using primitives::ticket::Ticket;
   using primitives::tipset::HeadChange;
@@ -299,15 +300,7 @@ namespace fc::api {
                const TokenAmount &,
                const TipsetKey &)
 
-    API_METHOD(MinerCreateBlock,
-               BlockMsg,
-               const Address &,
-               const TipsetKey &,
-               const Ticket &,
-               const EPostProof &,
-               const std::vector<SignedMessage> &,
-               ChainEpoch,
-               uint64_t)
+    API_METHOD(MinerCreateBlock, BlockMsg, const BlockTemplate &)
     API_METHOD(MinerGetBaseInfo,
                MiningBaseInfo,
                const Address &,

core/api/make.cpp

@@ -8,7 +8,7 @@
 #include <boost/algorithm/string.hpp>
 #include <libp2p/peer/peer_id.hpp>
 
-#include "blockchain/production/impl/block_producer_impl.hpp"
+#include "blockchain/production/block_producer.hpp"
 #include "storage/hamt/hamt.hpp"
 #include "vm/actor/builtin/account/account_actor.hpp"
 #include "vm/actor/builtin/init/init_actor.hpp"
@@ -33,7 +33,6 @@ namespace fc::api {
   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 libp2p::peer::PeerId;
@@ -248,34 +247,12 @@ namespace fc::api {
         .ClientStartDeal = {},
         // TODO(turuslan): FIL-165 implement method
         .MarketEnsureAvailable = {},
-        .MinerCreateBlock = {[=](auto &miner,
-                                 auto &parent,
-                                 auto &ticket,
-                                 auto &proof,
-                                 auto &messages,
-                                 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>(),
-          };
+        .MinerCreateBlock = {[=](auto &t) -> outcome::result<BlockMsg> {
+          OUTCOME_TRY(context, tipsetContext(t.parents, true));
+          OUTCOME_TRY(miner_state, context.minerState(t.miner));
           OUTCOME_TRY(block,
-                      producer.generate(miner,
-                                        context.tipset,
-                                        *context.interpreted,
-                                        proof,
-                                        ticket,
-                                        messages,
-                                        height,
-                                        timestamp));
-
-          OUTCOME_TRY(miner_state, context.minerState(miner));
+                      blockchain::production::generate(ipld, std::move(t)));
+
           OUTCOME_TRY(block_signable, codec::cbor::encode(block.header));
           OUTCOME_TRY(worker_key, context.accountKey(miner_state.info.worker));
           OUTCOME_TRY(block_sig, key_store->sign(worker_key, block_signable));

core/api/rpc/json.hpp

@@ -30,7 +30,9 @@ namespace fc::api {
   using crypto::signature::Signature;
   using markets::storage::StorageAsk;
   using primitives::BigInt;
+  using primitives::block::BeaconEntry;
   using primitives::block::BlockHeader;
+  using primitives::block::ElectionProof;
   using primitives::cid::getCidOfCbor;
   using primitives::sector::PoStProof;
   using primitives::sector::RegisteredProof;
@@ -350,7 +352,9 @@ namespace fc::api {
       Value j{rapidjson::kObjectType};
       Set(j, "Miner", v.miner);
       Set(j, "Ticket", v.ticket);
-      Set(j, "EPostProof", v.epost_proof);
+      Set(j, "ElectionProof", v.election_proof);
+      Set(j, "BeaconEntries", v.beacon_entries);
+      Set(j, "WinPoStProof", v.win_post_proof);
       Set(j, "Parents", v.parents);
       Set(j, "ParentWeight", v.parent_weight);
       Set(j, "Height", v.height);
@@ -367,7 +371,9 @@ namespace fc::api {
     DECODE(BlockHeader) {
       decode(v.miner, Get(j, "Miner"));
       decode(v.ticket, Get(j, "Ticket"));
-      decode(v.epost_proof, Get(j, "EPostProof"));
+      decode(v.election_proof, Get(j, "ElectionProof"));
+      decode(v.beacon_entries, Get(j, "BeaconEntries"));
+      decode(v.win_post_proof, Get(j, "WinPoStProof"));
       decode(v.parents, Get(j, "Parents"));
       decode(v.parent_weight, Get(j, "ParentWeight"));
       decode(v.height, Get(j, "Height"));
@@ -380,6 +386,40 @@ namespace fc::api {
       decode(v.fork_signaling, Get(j, "ForkSignaling"));
     }
 
+    DECODE(BlockTemplate) {
+      decode(v.miner, Get(j, "Miner"));
+      decode(v.parents, Get(j, "Parents"));
+      decode(v.ticket, Get(j, "Ticket"));
+      decode(v.election_proof, Get(j, "Eproof"));
+      decode(v.beacon_entries, Get(j, "BeaconValues"));
+      decode(v.messages, Get(j, "Messages"));
+      decode(v.height, Get(j, "Epoch"));
+      decode(v.timestamp, Get(j, "Timestamp"));
+      decode(v.win_post_proof, Get(j, "WinningPoStProof"));
+    }
+
+    ENCODE(ElectionProof) {
+      Value j{rapidjson::kObjectType};
+      Set(j, "VRFProof", v.vrf_proof);
+      return j;
+    }
+
+    DECODE(ElectionProof) {
+      decode(v.vrf_proof, Get(j, "VRFProof"));
+    }
+
+    ENCODE(BeaconEntry) {
+      Value j{rapidjson::kObjectType};
+      Set(j, "Round", v.round);
+      Set(j, "Data", v.data);
+      return j;
+    }
+
+    DECODE(BeaconEntry) {
+      decode(v.round, Get(j, "Round"));
+      decode(v.data, Get(j, "Data"));
+    }
+
     ENCODE(Tipset) {
       Value j{rapidjson::kObjectType};
       Set(j, "Cids", v.cids);

core/blockchain/production/CMakeLists.txt

@@ -4,15 +4,11 @@
 #
 
 add_library(block_producer
-    impl/block_producer_impl.cpp
+    block_producer.cpp
     )
 target_link_libraries(block_producer
     bls_provider
-    outcome
-    buffer
-    address
-    clock
     interpreter
     tipset
-    ipfs_datastore_in_memory
+    weight_calculator
     )

core/blockchain/production/block_producer.cpp

@@ -0,0 +1,69 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "blockchain/production/block_producer.hpp"
+
+#include "blockchain/impl/weight_calculator_impl.hpp"
+#include "crypto/bls/impl/bls_provider_impl.hpp"
+#include "vm/interpreter/impl/interpreter_impl.hpp"
+
+namespace fc::blockchain::production {
+  using crypto::signature::BlsSignature;
+  using crypto::signature::Secp256k1Signature;
+  using primitives::block::MsgMeta;
+  using vm::message::SignedMessage;
+  using vm::message::UnsignedMessage;
+
+  outcome::result<Block> generate(std::shared_ptr<Ipld> ipld, BlockTemplate t) {
+    OUTCOME_TRY(parent_tipset,
+                primitives::tipset::Tipset::load(*ipld, t.parents));
+    OUTCOME_TRY(
+        vm_result,
+        vm::interpreter::InterpreterImpl{}.interpret(ipld, parent_tipset));
+    Block b;
+    MsgMeta msg_meta;
+    msg_meta.load(ipld);
+    std::vector<crypto::bls::Signature> bls_signatures;
+    for (auto &message : t.messages) {
+      OUTCOME_TRY(visit_in_place(
+          message.signature,
+          [&](const BlsSignature &signature) -> outcome::result<void> {
+            b.bls_messages.emplace_back(message.message);
+            bls_signatures.push_back(signature);
+            OUTCOME_TRY(message_cid, ipld->setCbor(message.message));
+            OUTCOME_TRY(msg_meta.bls_messages.append(message_cid));
+            return outcome::success();
+          },
+          [&](const Secp256k1Signature &signature) -> outcome::result<void> {
+            b.secp_messages.emplace_back(message);
+            OUTCOME_TRY(message_cid, ipld->setCbor(message));
+            OUTCOME_TRY(msg_meta.secp_messages.append(message_cid));
+            return outcome::success();
+          }));
+    }
+    b.header.miner = std::move(t.miner);
+    b.header.ticket = std::move(t.ticket);
+    b.header.election_proof = std::move(t.election_proof);
+    b.header.beacon_entries = std::move(t.beacon_entries);
+    b.header.win_post_proof = std::move(t.win_post_proof);
+    b.header.parents = std::move(t.parents);
+    OUTCOME_TRYA(
+        b.header.parent_weight,
+        weight::WeightCalculatorImpl{ipld}.calculateWeight(parent_tipset));
+    b.header.height = t.height;
+    b.header.parent_state_root = std::move(vm_result.state_root);
+    b.header.parent_message_receipts = std::move(vm_result.message_receipts);
+    OUTCOME_TRY(msg_meta.flush());
+    OUTCOME_TRYA(b.header.messages, ipld->setCbor(msg_meta));
+    OUTCOME_TRYA(
+        b.header.bls_aggregate,
+        crypto::bls::BlsProviderImpl{}.aggregateSignatures(bls_signatures));
+    b.header.timestamp = t.timestamp;
+    // TODO: the only caller of "generate" is MinerCreateBlock, it signs block
+    b.header.block_sig = {};
+    b.header.fork_signaling = 0;
+    return std::move(b);
+  }
+}  // namespace fc::blockchain::production

core/blockchain/production/block_producer.hpp

@@ -3,47 +3,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "common/outcome.hpp"
-#include "primitives/address/address.hpp"
 #include "primitives/block/block.hpp"
-#include "primitives/ticket/epost_ticket.hpp"
-#include "primitives/ticket/ticket.hpp"
 
 namespace fc::blockchain::production {
-  /**
-   * @class Generating new blocks for chain's tipset
-   */
-  class BlockProducer {
-   protected:
-    using Block = primitives::block::Block;
-    using Address = primitives::address::Address;
-    using EPostProof = primitives::ticket::EPostProof;
-    using Ticket = primitives::ticket::Ticket;
+  using primitives::block::Block;
+  using primitives::block::BlockTemplate;
+  using Ipld = storage::ipfs::IpfsDatastore;
 
-   public:
-    virtual ~BlockProducer() = default;
+  constexpr size_t kBlockMaxMessagesCount = 1000;
 
-    /**
-     * @brief Generate new block
-     * @param miner_address - source address
-     * @param parent_tipset_id - id of the parent tipset
-     * @param proof - evidence of mining permission
-     * @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) = 0;
-  };
-
-  /**
-   * @enum Block production errors
-   */
-  enum class BlockProducerError {
-    PARENT_TIPSET_NOT_FOUND = 1,
-    PARENT_TIPSET_INVALID_CONTENT
-  };
+  outcome::result<Block> generate(std::shared_ptr<Ipld> ipld, BlockTemplate t);
 }  // namespace fc::blockchain::production
-
-OUTCOME_HPP_DECLARE_ERROR(fc::blockchain::production, BlockProducerError);