Lite-mode for validate-query, more collated data in collator

validator/fabric.h

@@ -25,6 +25,8 @@ namespace ton {
 
 namespace validator {
 
+enum ValidateMode { fake = 1, lite = 2 };
+
 td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_);
 td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
                                                                    std::string db_root);
@@ -73,7 +75,7 @@ void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::act
 void run_validate_query(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
                         std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                        td::Promise<ValidateCandidateResult> promise, bool is_fake = false);
+                        td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
 void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& min_masterchain_block_id,
                        std::vector<BlockIdExt> prev, Ed25519_PublicKey local_id, td::Ref<ValidatorSet> validator_set,
                        td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,

validator/impl/collator-impl.h

@@ -205,7 +205,11 @@ class Collator final : public td::actor::Actor {
   unsigned block_create_total_{0};
   std::vector<ExtMessage::Hash> bad_ext_msgs_, delay_ext_msgs_;
   Ref<vm::Cell> shard_account_blocks_;  // ShardAccountBlocks
+
+  std::map<td::Bits256, Ref<BlockData>> blocks_with_state_proofs_;
+  std::vector<vm::MerkleProofBuilder> neighbor_proof_builders_;
   std::vector<Ref<vm::Cell>> collated_roots_;
+
   std::unique_ptr<ton::BlockCandidate> block_candidate;
 
   td::PerfWarningTimer perf_timer_{"collate", 0.1};
@@ -235,7 +239,8 @@ class Collator final : public td::actor::Actor {
   void after_get_aux_shard_state(ton::BlockIdExt blkid, td::Result<Ref<ShardState>> res);
   bool fix_one_processed_upto(block::MsgProcessedUpto& proc, const ton::ShardIdFull& owner);
   bool fix_processed_upto(block::MsgProcessedUptoCollection& upto);
-  void got_neighbor_out_queue(int i, td::Result<Ref<MessageQueue>> res);
+  void got_neighbor_block_data(td::Result<Ref<BlockData>> res);
+  void got_neighbor_block_state(int i, td::Result<Ref<ShardState>> res);
   bool adjust_shard_config();
   bool store_shard_fees(ShardIdFull shard, const block::CurrencyCollection& fees,
                         const block::CurrencyCollection& created);

validator/impl/collator.cpp

@@ -502,6 +502,7 @@ void Collator::after_get_block_data(int idx, td::Result<Ref<BlockData>> res) {
       prev_mc_block = prev_block_data[0];
       mc_block_root = prev_mc_block->root_cell();
     }
+    blocks_with_state_proofs_[prev_block_data[idx]->root_cell()->get_hash().bits()] = prev_block_data[idx];
   }
   check_pending();
 }
@@ -614,26 +615,59 @@ bool Collator::request_neighbor_msg_queues() {
     neighbors_.emplace_back(*shard_ptr);
   }
   int i = 0;
+  neighbor_proof_builders_.resize(neighbors_.size());
   for (block::McShardDescr& descr : neighbors_) {
     LOG(DEBUG) << "neighbor #" << i << " : " << descr.blk_.to_str();
+    if (descr.blk_.seqno() != 0) {
       ++pending;
-    send_closure_later(manager, &ValidatorManager::wait_block_message_queue_short, descr.blk_, priority(), timeout,
+      send_closure_later(manager, &ValidatorManager::wait_block_data_short, descr.blk_, priority(), timeout,
-                       [self = get_self(), i](td::Result<Ref<MessageQueue>> res) {
+                         [self = get_self(), i](td::Result<Ref<BlockData>> res) {
-                         td::actor::send_closure(std::move(self), &Collator::got_neighbor_out_queue, i, std::move(res));
+                           LOG(DEBUG) << "got answer to wait_block_data for neighbor #" << i;
+                           send_closure_later(std::move(self), &Collator::got_neighbor_block_data, std::move(res));
+                         });
+    }
+    ++pending;
+    send_closure_later(manager, &ValidatorManager::wait_block_state_short, descr.blk_, priority(), timeout,
+                       [self = get_self(), i](td::Result<Ref<ShardState>> res) {
+                         LOG(DEBUG) << "got answer to wait_block_state for neighbor #" << i;
+                         send_closure_later(std::move(self), &Collator::got_neighbor_block_state, i, std::move(res));
                        });
     ++i;
   }
   return true;
 }
 
-void Collator::got_neighbor_out_queue(int i, td::Result<Ref<MessageQueue>> res) {
+void Collator::got_neighbor_block_data(td::Result<Ref<BlockData>> res) {
-  LOG(DEBUG) << "obtained outbound queue for neighbor #" << i;
   --pending;
   if (res.is_error()) {
     fatal_error(res.move_as_error());
     return;
   }
-  Ref<MessageQueue> outq_descr = res.move_as_ok();
+  auto block_data = res.move_as_ok();
+  blocks_with_state_proofs_[block_data->root_cell()->get_hash().bits()] = block_data;
+  check_pending();
+}
+
+void Collator::got_neighbor_block_state(int i, td::Result<Ref<ShardState>> res) {
+  --pending;
+  if (res.is_error()) {
+    fatal_error(res.move_as_error());
+    return;
+  }
+  Ref<ShardState> state = res.move_as_ok();
+  neighbor_proof_builders_.at(i) = vm::MerkleProofBuilder{state->root_cell()};
+  auto new_state = ShardStateQ::fetch(state->get_block_id(), {}, neighbor_proof_builders_.at(i).root());
+  if (new_state.is_error()) {
+    fatal_error(new_state.move_as_error());
+    return;
+  }
+  auto outq_descr_res = new_state.move_as_ok()->message_queue();
+  if (outq_descr_res.is_error()) {
+    fatal_error(outq_descr_res.move_as_error());
+    return;
+  }
+  LOG(DEBUG) << "obtained outbound queue for neighbor #" << i;
+  Ref<MessageQueue> outq_descr = outq_descr_res.move_as_ok();
   block::McShardDescr& descr = neighbors_.at(i);
   if (outq_descr->get_block_id() != descr.blk_) {
     LOG(DEBUG) << "outq_descr->id = " << outq_descr->get_block_id().to_str() << " ; descr.id = " << descr.blk_.to_str();
@@ -3949,7 +3983,6 @@ Ref<vm::Cell> Collator::collate_shard_block_descr_set() {
 }
 
 bool Collator::create_collated_data() {
-  // TODO: store something into collated_roots_
   // 1. store the set of used shard block descriptions
   if (!used_shard_block_descr_.empty()) {
     auto cell = collate_shard_block_descr_set();
@@ -3959,7 +3992,47 @@ bool Collator::create_collated_data() {
     }
     collated_roots_.push_back(std::move(cell));
   }
-  // 2. ...
+  // 2. Proofs for hashes of states: previous states + neighbors
+  for (const auto& p : blocks_with_state_proofs_) {
+    vm::MerkleProofBuilder mpb{p.second->root_cell()};
+    block::gen::Block::Record block;
+    if (!tlb::unpack_cell(mpb.root(), block) || block.state_update->load_cell().is_error()) {
+      return fatal_error("cannot generate Merkle proof for previous block");
+    }
+    Ref<vm::Cell> proof = mpb.extract_proof();
+    if (proof.is_null()) {
+      return fatal_error("cannot generate Merkle proof for previous block");
+    }
+    collated_roots_.push_back(std::move(proof));
+  }
+  // 3. Previous state proof (only shadchains)
+  std::map<td::Bits256, Ref<vm::Cell>> proofs;
+  if (!is_masterchain()) {
+    state_usage_tree_->set_use_mark_for_is_loaded(false);
+    Ref<vm::Cell> state_proof = vm::MerkleProof::generate(prev_state_root_, state_usage_tree_.get());
+    if (state_proof.is_null()) {
+      return fatal_error("cannot generate Merkle proof for previous state");
+    }
+    proofs[prev_state_root_->get_hash().bits()] = std::move(state_proof);
+  }
+  // 4. Proofs for message queues
+  for (vm::MerkleProofBuilder &mpb : neighbor_proof_builders_) {
+    Ref<vm::Cell> proof = mpb.extract_proof();
+    if (proof.is_null()) {
+      return fatal_error("cannot generate Merkle proof for neighbor");
+    }
+    auto it = proofs.emplace(mpb.root()->get_hash().bits(), proof);
+    if (!it.second) {
+      it.first->second = vm::MerkleProof::combine(it.first->second, std::move(proof));
+      if (it.first->second.is_null()) {
+        return fatal_error("cannot combine merkle proofs");
+      }
+    }
+  }
+
+  for (auto& p : proofs) {
+    collated_roots_.push_back(std::move(p.second));
+  }
   return true;
 }
 

validator/impl/fabric.cpp

@@ -191,17 +191,18 @@ void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::act
 void run_validate_query(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
                         std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                        td::Promise<ValidateCandidateResult> promise, bool is_fake) {
+                        td::Promise<ValidateCandidateResult> promise, unsigned mode) {
   BlockSeqno seqno = 0;
   for (auto& p : prev) {
     if (p.seqno() > seqno) {
       seqno = p.seqno();
     }
   }
+  bool is_fake = mode & ValidateMode::fake;
   td::actor::create_actor<ValidateQuery>(
       PSTRING() << (is_fake ? "fakevalidate" : "validateblock") << shard.to_str() << ":" << (seqno + 1), shard, min_ts,
       min_masterchain_block_id, std::move(prev), std::move(candidate), std::move(validator_set), std::move(manager),
-      timeout, std::move(promise), is_fake)
+      timeout, std::move(promise), mode)
       .release();
 }
 

validator/impl/validate-query.cpp

@@ -31,6 +31,7 @@
 #include "vm/cells/MerkleProof.h"
 #include "vm/cells/MerkleUpdate.h"
 #include "common/errorlog.h"
+#include "fabric.h"
 #include <ctime>
 
 namespace ton {
@@ -51,7 +52,7 @@ std::string ErrorCtx::as_string() const {
 ValidateQuery::ValidateQuery(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
                              std::vector<BlockIdExt> prev, BlockCandidate candidate, Ref<ValidatorSet> validator_set,
                              td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                             td::Promise<ValidateCandidateResult> promise, bool is_fake)
+                             td::Promise<ValidateCandidateResult> promise, unsigned mode)
     : shard_(shard)
     , id_(candidate.id)
     , min_ts(min_ts)
@@ -62,7 +63,8 @@ ValidateQuery::ValidateQuery(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_
     , manager(std::move(manager))
     , timeout(timeout)
     , main_promise(std::move(promise))
-    , is_fake_(is_fake)
+    , is_fake_(mode & ValidateMode::fake)
+    , is_lite_(mode & ValidateMode::lite)
     , shard_pfx_(shard_.shard)
     , shard_pfx_len_(ton::shard_prefix_length(shard_)) {
   proc_hash_.zero();
@@ -257,8 +259,9 @@ void ValidateQuery::start_up() {
                                   td::actor::send_closure_later(
                                       std::move(self), &ValidateQuery::after_get_latest_mc_state, std::move(res));
                                 });
-  // 3. load state(s) corresponding to previous block(s)
+  // 3. load state(s) corresponding to previous block(s) (non-lite mode or masterchain)
   prev_states.resize(prev_blocks.size());
+  if  (is_masterchain() || !is_lite_) {
     for (int i = 0; (unsigned)i < prev_blocks.size(); i++) {
       // 3.1. load state
       LOG(DEBUG) << "sending wait_block_state() query #" << i << " for " << prev_blocks[i].to_str() << " to Manager";
@@ -270,6 +273,7 @@ void ValidateQuery::start_up() {
                                           std::move(self), &ValidateQuery::after_get_shard_state, i, std::move(res));
                                     });
     }
+  }
   // 4. unpack block candidate (while necessary data is being loaded)
   if (!unpack_block_candidate()) {
     reject_query("error unpacking block candidate");
@@ -988,6 +992,9 @@ bool ValidateQuery::check_this_shard_mc_info() {
  */
 
 bool ValidateQuery::compute_prev_state() {
+  if (!is_masterchain() && is_lite_) {
+    return compute_prev_state_lite_mode();
+  }
   CHECK(prev_states.size() == 1u + after_merge_);
   prev_state_root_ = prev_states[0]->root_cell();
   CHECK(prev_state_root_.not_null());
@@ -1006,6 +1013,46 @@ bool ValidateQuery::compute_prev_state() {
   return true;
 }
 
+bool ValidateQuery::compute_prev_state_lite_mode() {
+  td::Bits256 state_hash;
+  if (id_.seqno() == 1) {
+    if (prev_blocks.size() != 1) {
+      return reject_query("seqno is 1, but number of previous blocks is not 1");
+    }
+    state_hash = prev_blocks[0].root_hash;
+  } else {
+    std::vector<Ref<vm::Cell>> prev_state_roots(prev_blocks.size());
+    for (size_t i = 0; i < prev_blocks.size(); ++i) {
+      prev_state_roots[i] = get_virt_state_root(prev_blocks[i].root_hash);
+      if (prev_state_roots[i].is_null()) {
+        return reject_query(PSTRING() << "cannot get hash of previous state root: " << prev_blocks[i]);
+      }
+    }
+
+    if (prev_state_roots.size() == 1) {
+      state_hash = prev_state_roots[0]->get_hash().bits();
+    } else {
+      CHECK(prev_state_roots.size() == 2);
+      Ref<vm::Cell> merged;
+      if (!block::gen::t_ShardState.cell_pack_split_state(merged, prev_state_roots[0], prev_state_roots[1])) {
+        return fatal_error(-667, "cannot construct mechanically merged previously state");
+      }
+      state_hash = merged->get_hash().bits();
+    }
+  }
+  if (state_hash != prev_state_hash_) {
+    return reject_query("previous state hash mismatch for block "s + id_.to_str() + " : block header declares " +
+                        prev_state_hash_.to_hex() + " , actual " + state_hash.to_hex());
+  }
+  auto it = virt_roots_.find(state_hash);
+  if (it == virt_roots_.end()) {
+    return reject_query(PSTRING() << "no state root for previous block in collated data (hash = "
+                                  << state_hash.to_hex() << ")");
+  }
+  prev_state_root_ = it->second;
+  return true;
+}
+
 bool ValidateQuery::compute_next_state() {
   LOG(DEBUG) << "computing next state";
   auto res = vm::MerkleUpdate::validate(state_update_);
@@ -1209,6 +1256,32 @@ bool ValidateQuery::request_neighbor_queues() {
     neighbors_.emplace_back(*shard_ptr);
   }
   int i = 0;
+  if (is_lite_) {
+    for (block::McShardDescr& descr : neighbors_) {
+      LOG(DEBUG) << "getting outbound queue of neighbor #" << i << " from collated data : " << descr.blk_.to_str();
+      td::Bits256 state_root_hash;
+      if (descr.blk_.seqno() == 0) {
+        state_root_hash = descr.blk_.root_hash;
+      } else {
+        Ref<vm::Cell> state_root = get_virt_state_root(descr.blk_.root_hash);
+        if (state_root.is_null()) {
+          return reject_query(PSTRING() << "cannot get hash of state root: " << descr.blk_);
+        }
+        state_root_hash = state_root->get_hash().bits();
+      }
+      auto it = virt_roots_.find(state_root_hash);
+      if (it == virt_roots_.end()) {
+        return reject_query(PSTRING() << "cannot get state root form collated data: " << descr.blk_);
+      }
+      auto state = ShardStateQ::fetch(descr.blk_, {}, it->second);
+      if (state.is_error()) {
+        return reject_query("cannot fetch shard state from collated data", state.move_as_error());
+      }
+      ++pending;
+      send_closure_later(get_self(), &ValidateQuery::got_neighbor_out_queue, i, state.move_as_ok()->message_queue());
+      ++i;
+    }
+  } else {
     for (block::McShardDescr& descr : neighbors_) {
       LOG(DEBUG) << "requesting outbound queue of neighbor #" << i << " : " << descr.blk_.to_str();
       ++pending;
@@ -1219,6 +1292,7 @@ bool ValidateQuery::request_neighbor_queues() {
                          });
       ++i;
     }
+  }
   return true;
 }
 
@@ -5430,6 +5504,24 @@ bool ValidateQuery::check_mc_block_extra() {
   return true;
 }
 
+Ref<vm::Cell> ValidateQuery::get_virt_state_root(td::Bits256 block_root_hash) {
+  auto it = virt_roots_.find(block_root_hash);
+  if (it == virt_roots_.end()) {
+    return {};
+  }
+  Ref<vm::Cell> root = it->second;
+  block::gen::Block::Record block;
+  if (!tlb::unpack_cell(root, block)) {
+    return {};
+  }
+  vm::CellSlice upd_cs{vm::NoVmSpec(), block.state_update};
+  if (!(upd_cs.is_special() && upd_cs.prefetch_long(8) == 4  // merkle update
+        && upd_cs.size_ext() == 0x20228)) {
+    return {};
+  }
+  return vm::MerkleProof::virtualize_raw(upd_cs.prefetch_ref(1), {0, 1});
+}
+
 /*
  *
  *   MAIN VALIDATOR FUNCTION
@@ -5533,7 +5625,7 @@ bool ValidateQuery::try_validate() {
   } catch (vm::VmError& err) {
     return fatal_error(-666, err.get_msg());
   } catch (vm::VmVirtError& err) {
-    return fatal_error(-666, err.get_msg());
+    return reject_query(err.get_msg());
   }
   return save_candidate();
 }

validator/impl/validate-query.hpp

@@ -118,7 +118,7 @@ class ValidateQuery : public td::actor::Actor {
   ValidateQuery(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
                 BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                 td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                td::Promise<ValidateCandidateResult> promise, bool is_fake = false);
+                td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
 
  private:
   int verbosity{3 * 1};
@@ -142,6 +142,7 @@ class ValidateQuery : public td::actor::Actor {
   bool is_key_block_{false};
   bool update_shard_cc_{false};
   bool is_fake_{false};
+  bool is_lite_{false};
   bool prev_key_block_exists_{false};
   bool debug_checks_{false};
   bool outq_cleanup_partial_{false};
@@ -286,6 +287,7 @@ class ValidateQuery : public td::actor::Actor {
   bool extract_collated_data();
   bool try_validate();
   bool compute_prev_state();
+  bool compute_prev_state_lite_mode();
   bool compute_next_state();
   bool unpack_merge_prev_state();
   bool unpack_prev_state();
@@ -368,6 +370,8 @@ class ValidateQuery : public td::actor::Actor {
   bool check_one_shard_fee(ShardIdFull shard, const block::CurrencyCollection& fees,
                            const block::CurrencyCollection& create);
   bool check_mc_block_extra();
+
+  Ref<vm::Cell> get_virt_state_root(td::Bits256 block_root_hash);
 };
 
 }  // namespace validator

validator/manager-disk.cpp

@@ -153,7 +153,7 @@ void ValidatorManagerImpl::validate_fake(BlockCandidate candidate, std::vector<B
   });
   auto shard = candidate.id.shard_full();
   run_validate_query(shard, 0, last, prev, std::move(candidate), std::move(val_set), actor_id(this),
-                     td::Timestamp::in(10.0), std::move(P), true /* fake */);
+                     td::Timestamp::in(10.0), std::move(P), ValidateMode::fake);
 }
 
 void ValidatorManagerImpl::write_fake(BlockCandidate candidate, std::vector<BlockIdExt> prev, BlockIdExt last,