Debug logs for applying blocks

SpyCheese · SpyCheese · commit 06675603e9f8 · 2025-10-20T17:36:55.000+03:00
diff --git a/validator/apply-block.cpp b/validator/apply-block.cpp
@@ -29,7 +29,7 @@ namespace validator {
 
 void ApplyBlock::abort_query(td::Status reason) {
   if (promise_) {
-    VLOG(VALIDATOR_WARNING) << "aborting apply block query for " << id_ << ": " << reason;
+    VLOG(VALIDATOR_WARNING) << "aborting apply block query for " << id_.to_str() << ": " << reason;
     promise_.set_error(std::move(reason));
   }
   stop();
@@ -51,7 +51,7 @@ void ApplyBlock::alarm() {
 }
 
 void ApplyBlock::start_up() {
-  VLOG(VALIDATOR_DEBUG) << "running apply_block for " << id_;
+  VLOG(VALIDATOR_DEBUG) << "running apply_block for " << id_.to_str() << ", mc_seqno=" << masterchain_block_id_.seqno();
 
   if (id_.is_masterchain()) {
     masterchain_block_id_ = id_;
@@ -71,6 +71,7 @@ void ApplyBlock::start_up() {
 }
 
 void ApplyBlock::got_block_handle(BlockHandle handle) {
+  VLOG(VALIDATOR_DEBUG) << "got_block_handle";
   handle_ = std::move(handle);
 
   if (handle_->is_applied() && (!handle_->id().is_masterchain() || handle_->processed())) {
@@ -79,6 +80,7 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {
   }
 
   if (handle_->is_applied()) {
+    VLOG(VALIDATOR_DEBUG) << "already applied";
     auto P =
         td::PromiseCreator::lambda([SelfId = actor_id(this), seqno = handle_->id().id.seqno](td::Result<BlockIdExt> R) {
           R.ensure();
@@ -94,16 +96,19 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {
   }
 
   if (handle_->id().id.seqno == 0) {
+    VLOG(VALIDATOR_DEBUG) << "seqno == 0";
     written_block_data();
     return;
   }
 
   if (handle_->is_archived()) {
+    VLOG(VALIDATOR_DEBUG) << "already archived";
     finish_query();
     return;
   }
 
   if (handle_->received()) {
+    VLOG(VALIDATOR_DEBUG) << "already received";
     written_block_data();
     return;
   }
@@ -117,6 +122,7 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {
       }
     });
 
+    VLOG(VALIDATOR_DEBUG) << "storing block data";
     td::actor::send_closure(manager_, &ValidatorManager::set_block_data, handle_, block_, std::move(P));
   } else {
     auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), handle = handle_](td::Result<td::Ref<BlockData>> R) {
@@ -128,13 +134,14 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {
       }
     });
 
+    VLOG(VALIDATOR_DEBUG) << "wait for block data";
     td::actor::send_closure(manager_, &ValidatorManager::wait_block_data, handle_, apply_block_priority(), timeout_,
                             std::move(P));
   }
 }
 
 void ApplyBlock::written_block_data() {
-  VLOG(VALIDATOR_DEBUG) << "apply block: written block data for " << id_;
+  VLOG(VALIDATOR_DEBUG) << "written_block_data";
   if (!handle_->id().seqno()) {
     CHECK(handle_->inited_split_after());
     CHECK(handle_->inited_state_root_hash());
@@ -165,24 +172,26 @@ void ApplyBlock::written_block_data() {
       }
     });
 
+    VLOG(VALIDATOR_DEBUG) << "wait_block_state";
     td::actor::send_closure(manager_, &ValidatorManager::wait_block_state, handle_, apply_block_priority(), timeout_,
                             true, std::move(P));
   }
 }
 
 void ApplyBlock::got_cur_state(td::Ref<ShardState> state) {
-  VLOG(VALIDATOR_DEBUG) << "apply block: received state for " << id_;
+  VLOG(VALIDATOR_DEBUG) << "got_cur_state";
   state_ = std::move(state);
   CHECK(handle_->received_state());
   written_state();
 }
 
 void ApplyBlock::written_state() {
+  VLOG(VALIDATOR_DEBUG) << "written_state";
   if (handle_->is_applied() && handle_->processed()) {
     finish_query();
     return;
   }
-  VLOG(VALIDATOR_DEBUG) << "apply block: setting next for parents of " << id_;
+  VLOG(VALIDATOR_DEBUG) << "setting next for parents";
 
   if (handle_->id().id.seqno != 0 && !handle_->is_applied()) {
     auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
@@ -208,12 +217,13 @@ void ApplyBlock::written_state() {
 }
 
 void ApplyBlock::written_next() {
+  VLOG(VALIDATOR_DEBUG) << "written_next";
   if (handle_->is_applied() && handle_->processed()) {
     finish_query();
     return;
   }
 
-  VLOG(VALIDATOR_DEBUG) << "apply block: applying parents of " << id_;
+  VLOG(VALIDATOR_DEBUG) << "applying parents";
 
   if (handle_->id().id.seqno != 0 && !handle_->is_applied()) {
     auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
@@ -241,7 +251,8 @@ void ApplyBlock::written_next() {
 }
 
 void ApplyBlock::applied_prev() {
-  VLOG(VALIDATOR_DEBUG) << "apply block: waiting manager's confirm for " << id_;
+  VLOG(VALIDATOR_DEBUG) << "applying parents";
+  VLOG(VALIDATOR_DEBUG) << "applied_prev, waiting manager's confirm";
   if (!id_.is_masterchain()) {
     handle_->set_masterchain_ref_block(masterchain_block_id_.seqno());
   }
@@ -253,10 +264,11 @@ void ApplyBlock::applied_prev() {
     }
   });
   td::actor::send_closure(manager_, &ValidatorManager::new_block, handle_, state_, std::move(P));
+
 }
 
 void ApplyBlock::applied_set() {
-  VLOG(VALIDATOR_DEBUG) << "apply block: setting apply bit for " << id_;
+  VLOG(VALIDATOR_DEBUG) << "applied_set";
   handle_->set_applied();
   if (handle_->id().seqno() > 0) {
     CHECK(handle_->handle_moved_to_archive());
@@ -270,6 +282,7 @@ void ApplyBlock::applied_set() {
         td::actor::send_closure(SelfId, &ApplyBlock::finish_query);
       }
     });
+    VLOG(VALIDATOR_DEBUG) << "flush handle";
     handle_->flush(manager_, handle_, std::move(P));
   } else {
     finish_query();
diff --git a/validator/impl/accept-block.cpp b/validator/impl/accept-block.cpp
@@ -350,6 +350,7 @@ bool AcceptBlockQuery::check_send_error(td::actor::ActorId<AcceptBlockQuery> Sel
 }
 
 void AcceptBlockQuery::finish_query() {
+  VLOG(VALIDATOR_DEBUG) << "finish_query()";
   if (apply_) {
     ValidatorInvariants::check_post_accept(handle_);
   }
@@ -448,6 +449,7 @@ void AcceptBlockQuery::got_block_candidate_data(td::BufferSlice data) {
 }
 
 void AcceptBlockQuery::got_block_handle_cont() {
+  VLOG(VALIDATOR_DEBUG) << "got_block_handle_cont()";
   if (data_.not_null() && !handle_->received()) {
     td::actor::send_closure(
         manager_, &ValidatorManager::set_block_data, handle_, data_, [SelfId = actor_id(this)](td::Result<td::Unit> R) {
@@ -514,9 +516,11 @@ void AcceptBlockQuery::written_block_info() {
           td::actor::send_closure_bool(SelfId, &AcceptBlockQuery::got_prev_state, R.move_as_ok());
     });
 
+    VLOG(VALIDATOR_DEBUG) << "wait_prev_block_state";
     td::actor::send_closure(manager_, &ValidatorManager::wait_prev_block_state, handle_, priority(), timeout_,
                             std::move(P));
   } else {
+    VLOG(VALIDATOR_DEBUG) << "wait_block_data";
     td::actor::send_closure(manager_, &ValidatorManager::wait_block_data, handle_, priority(), timeout_,
                             [SelfId = actor_id(this)](td::Result<td::Ref<BlockData>> R) {
                               check_send_error(SelfId, R) ||
diff --git a/validator/impl/check-proof.cpp b/validator/impl/check-proof.cpp
@@ -43,7 +43,7 @@ void CheckProof::alarm() {
 
 void CheckProof::abort_query(td::Status reason) {
   if (promise_) {
-    VLOG(VALIDATOR_WARNING) << "aborting check proof for " << id_ << " query: " << reason;
+    VLOG(VALIDATOR_WARNING) << "aborting check proof for " << id_.to_str() << " query: " << reason;
     promise_.set_error(std::move(reason));
   }
   stop();
@@ -271,6 +271,7 @@ bool CheckProof::init_parse(bool is_aux) {
 }
 
 void CheckProof::start_up() {
+  VLOG(VALIDATOR_DEBUG) << "started check proof for " << id_.to_str() << ", mode=" << mode_;
   alarm_timestamp() = timeout_;
 
   auto res = vm::std_boc_deserialize(proof_->data());
@@ -324,6 +325,7 @@ void CheckProof::start_up() {
 }
 
 void CheckProof::got_block_handle(BlockHandle handle) {
+  VLOG(VALIDATOR_DEBUG) << "got_block_handle";
   handle_ = std::move(handle);
   CHECK(handle_);
   if (!is_proof() || skip_check_signatures_) {
@@ -353,6 +355,7 @@ void CheckProof::got_block_handle(BlockHandle handle) {
 }
 
 void CheckProof::got_masterchain_state(td::Ref<MasterchainState> state) {
+  VLOG(VALIDATOR_DEBUG) << "got_masterchain_state #" << state->get_seqno();
   CHECK(is_proof());
   state_ = std::move(state);
 
@@ -366,6 +369,7 @@ void CheckProof::got_masterchain_state(td::Ref<MasterchainState> state) {
 }
 
 void CheckProof::process_masterchain_state() {
+  VLOG(VALIDATOR_DEBUG) << "process_masterchain_state";
   CHECK(is_proof());
   CHECK(state_.not_null());
 
@@ -396,6 +400,7 @@ void CheckProof::process_masterchain_state() {
 }
 
 void CheckProof::check_signatures(Ref<ValidatorSet> s) {
+  VLOG(VALIDATOR_DEBUG) << "check_signatures";
   if (s->get_catchain_seqno() != catchain_seqno_) {
     abort_query(td::Status::Error(ErrorCode::protoviolation, PSTRING() << "bad validator catchain seqno: expected "
                                                                        << s->get_catchain_seqno() << ", found "
@@ -449,6 +454,7 @@ void CheckProof::check_signatures(Ref<ValidatorSet> s) {
 }
 
 void CheckProof::got_block_handle_2(BlockHandle handle) {
+  VLOG(VALIDATOR_DEBUG) << "got_block_handle_2 " << handle->id().id.to_str();
   handle_ = std::move(handle);
 
   handle_->set_split(before_split_);
@@ -468,16 +474,19 @@ void CheckProof::got_block_handle_2(BlockHandle handle) {
     // do not save proof if we skipped signatures
     auto proof = Ref<Proof>(proof_);
     CHECK(proof.not_null());
+    VLOG(VALIDATOR_DEBUG) << "set_block_proof";
     td::actor::send_closure_later(manager_, &ValidatorManager::set_block_proof, handle_, std::move(proof),
                                   std::move(P));
   } else if (is_proof()) {
     auto proof = Ref<Proof>(proof_);
     CHECK(proof.not_null());
     CHECK(sig_ok_);
+    VLOG(VALIDATOR_DEBUG) << "set_block_proof";
     td::actor::send_closure_later(manager_, &ValidatorManager::set_block_proof, handle_, std::move(proof),
                                   std::move(P));
   } else {
     CHECK(proof_.not_null());
+    VLOG(VALIDATOR_DEBUG) << "set_block_proof_link";
     td::actor::send_closure_later(manager_, &ValidatorManager::set_block_proof_link, handle_, proof_, std::move(P));
   }
 }
diff --git a/validator/impl/fabric.cpp b/validator/impl/fabric.cpp
@@ -158,37 +158,39 @@ void run_hardfork_accept_block_query(BlockIdExt id, td::Ref<BlockData> data,
 void run_apply_block_query(BlockIdExt id, td::Ref<BlockData> block, BlockIdExt masterchain_block_id,
                            td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                            td::Promise<td::Unit> promise) {
-  td::actor::create_actor<ApplyBlock>(PSTRING() << "apply " << id, id, std::move(block), masterchain_block_id, manager,
-                                      timeout, std::move(promise))
+  td::actor::create_actor<ApplyBlock>(PSTRING() << "apply" << id.id.to_str(), id, std::move(block),
+                                      masterchain_block_id, manager, timeout, std::move(promise))
       .release();
 }
 
 void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::ActorId<ValidatorManager> manager,
                            td::Timestamp timeout, td::Promise<BlockHandle> promise, bool skip_check_signatures) {
-  td::actor::create_actor<CheckProof>("checkproof", id, std::move(proof), manager, timeout, std::move(promise),
-                                      skip_check_signatures)
+  td::actor::create_actor<CheckProof>(PSTRING() << "checkproof" << id.id.to_str(), id, std::move(proof), manager,
+                                      timeout, std::move(promise), skip_check_signatures)
       .release();
 }
 
 void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::ActorId<ValidatorManager> manager,
                            td::Timestamp timeout, td::Promise<BlockHandle> promise,
                            td::Ref<ProofLink> rel_key_block_proof, bool skip_check_signatures) {
-  td::actor::create_actor<CheckProof>("checkproof/key", id, std::move(proof), manager, timeout, std::move(promise),
-                                      skip_check_signatures, std::move(rel_key_block_proof))
+  td::actor::create_actor<CheckProof>(PSTRING() << "checkproof/key" << id.id.to_str(), id, std::move(proof), manager,
+                                      timeout, std::move(promise), skip_check_signatures,
+                                      std::move(rel_key_block_proof))
       .release();
 }
 
 void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::ActorId<ValidatorManager> manager,
                            td::Timestamp timeout, td::Promise<BlockHandle> promise,
                            td::Ref<MasterchainState> rel_mc_state, bool skip_check_signatures) {
-  td::actor::create_actor<CheckProof>("checkproof/st", id, std::move(proof), manager, timeout, std::move(promise),
-                                      skip_check_signatures, std::move(rel_mc_state))
+  td::actor::create_actor<CheckProof>(PSTRING() << "checkproof/st" << id.id.to_str(), id, std::move(proof), manager,
+                                      timeout, std::move(promise), skip_check_signatures, std::move(rel_mc_state))
       .release();
 }
 
 void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::actor::ActorId<ValidatorManager> manager,
                                 td::Timestamp timeout, td::Promise<BlockHandle> promise) {
-  td::actor::create_actor<CheckProof>("checkprooflink", id, std::move(proof), manager, timeout, std::move(promise))
+  td::actor::create_actor<CheckProof>(PSTRING() << "checkprooflink" << id.id.to_str(), id, std::move(proof), manager,
+                                      timeout, std::move(promise))
       .release();
 }
 
diff --git a/validator/manager.cpp b/validator/manager.cpp
@@ -229,9 +229,10 @@ void ValidatorManagerImpl::new_block_broadcast(BlockBroadcast broadcast, td::Pro
     }
     promise.set_result(std::move(R));
   };
-  td::actor::create_actor<ValidateBroadcast>("broadcast", std::move(broadcast), last_masterchain_block_handle_,
-                                             last_masterchain_state_, last_known_key_block_handle_, actor_id(this),
-                                             td::Timestamp::in(2.0), std::move(promise))
+  BlockIdExt block_id = broadcast.block_id;
+  td::actor::create_actor<ValidateBroadcast>(
+      PSTRING() << "broadcast" << block_id.id.to_str(), std::move(broadcast), last_masterchain_block_handle_,
+      last_masterchain_state_, last_known_key_block_handle_, actor_id(this), td::Timestamp::in(2.0), std::move(promise))
       .release();
 }
 
diff --git a/validator/net/download-block.cpp b/validator/net/download-block.cpp
@@ -294,7 +294,7 @@ void DownloadBlock::got_block_partial_proof(td::BufferSlice proof) {
 }
 
 void DownloadBlock::checked_block_proof() {
-  VLOG(FULL_NODE_DEBUG) << "checked proof for " << block_id_;
+  VLOG(FULL_NODE_DEBUG) << "checked proof for " << block_id_.to_str();
 
   if (!handle_) {
     CHECK(!short_);
diff --git a/validator/validate-broadcast.cpp b/validator/validate-broadcast.cpp

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace validator {`
`29`	`29`
`30`	`30`	`void ApplyBlock::abort_query(td::Status reason) {`
`31`	`31`	`if (promise_) {`
`32`		`- VLOG(VALIDATOR_WARNING) << "aborting apply block query for " << id_ << ": " << reason;`
	`32`	`+ VLOG(VALIDATOR_WARNING) << "aborting apply block query for " << id_.to_str() << ": " << reason;`
`33`	`33`	`promise_.set_error(std::move(reason));`
`34`	`34`	`}`
`35`	`35`	`stop();`
`@@ -51,7 +51,7 @@ void ApplyBlock::alarm() {`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`void ApplyBlock::start_up() {`
`54`		`- VLOG(VALIDATOR_DEBUG) << "running apply_block for " << id_;`
	`54`	`+ VLOG(VALIDATOR_DEBUG) << "running apply_block for " << id_.to_str() << ", mc_seqno=" << masterchain_block_id_.seqno();`
`55`	`55`
`56`	`56`	`if (id_.is_masterchain()) {`
`57`	`57`	`masterchain_block_id_ = id_;`
`@@ -71,6 +71,7 @@ void ApplyBlock::start_up() {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`void ApplyBlock::got_block_handle(BlockHandle handle) {`
	`74`	`+ VLOG(VALIDATOR_DEBUG) << "got_block_handle";`
`74`	`75`	`handle_ = std::move(handle);`
`75`	`76`
`76`	`77`	`if (handle_->is_applied() && (!handle_->id().is_masterchain() \|\| handle_->processed())) {`
`@@ -79,6 +80,7 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`if (handle_->is_applied()) {`
	`83`	`+ VLOG(VALIDATOR_DEBUG) << "already applied";`
`82`	`84`	`auto P =`
`83`	`85`	`td::PromiseCreator::lambda([SelfId = actor_id(this), seqno = handle_->id().id.seqno](td::Result<BlockIdExt> R) {`
`84`	`86`	`R.ensure();`
`@@ -94,16 +96,19 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {`
`94`	`96`	`}`
`95`	`97`
`96`	`98`	`if (handle_->id().id.seqno == 0) {`
	`99`	`+ VLOG(VALIDATOR_DEBUG) << "seqno == 0";`
`97`	`100`	`written_block_data();`
`98`	`101`	`return;`
`99`	`102`	`}`
`100`	`103`
`101`	`104`	`if (handle_->is_archived()) {`
	`105`	`+ VLOG(VALIDATOR_DEBUG) << "already archived";`
`102`	`106`	`finish_query();`
`103`	`107`	`return;`
`104`	`108`	`}`
`105`	`109`
`106`	`110`	`if (handle_->received()) {`
	`111`	`+ VLOG(VALIDATOR_DEBUG) << "already received";`
`107`	`112`	`written_block_data();`
`108`	`113`	`return;`
`109`	`114`	`}`
`@@ -117,6 +122,7 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {`
`117`	`122`	`}`
`118`	`123`	`});`
`119`	`124`
	`125`	`+ VLOG(VALIDATOR_DEBUG) << "storing block data";`
`120`	`126`	`td::actor::send_closure(manager_, &ValidatorManager::set_block_data, handle_, block_, std::move(P));`
`121`	`127`	`} else {`
`122`	`128`	`auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), handle = handle_](td::Result<td::Ref<BlockData>> R) {`
`@@ -128,13 +134,14 @@ void ApplyBlock::got_block_handle(BlockHandle handle) {`
`128`	`134`	`}`
`129`	`135`	`});`
`130`	`136`
	`137`	`+ VLOG(VALIDATOR_DEBUG) << "wait for block data";`
`131`	`138`	`td::actor::send_closure(manager_, &ValidatorManager::wait_block_data, handle_, apply_block_priority(), timeout_,`
`132`	`139`	`std::move(P));`
`133`	`140`	`}`
`134`	`141`	`}`
`135`	`142`
`136`	`143`	`void ApplyBlock::written_block_data() {`
`137`		`- VLOG(VALIDATOR_DEBUG) << "apply block: written block data for " << id_;`
	`144`	`+ VLOG(VALIDATOR_DEBUG) << "written_block_data";`
`138`	`145`	`if (!handle_->id().seqno()) {`
`139`	`146`	`CHECK(handle_->inited_split_after());`
`140`	`147`	`CHECK(handle_->inited_state_root_hash());`
`@@ -165,24 +172,26 @@ void ApplyBlock::written_block_data() {`
`165`	`172`	`}`
`166`	`173`	`});`
`167`	`174`
	`175`	`+ VLOG(VALIDATOR_DEBUG) << "wait_block_state";`
`168`	`176`	`td::actor::send_closure(manager_, &ValidatorManager::wait_block_state, handle_, apply_block_priority(), timeout_,`
`169`	`177`	`true, std::move(P));`
`170`	`178`	`}`
`171`	`179`	`}`
`172`	`180`
`173`	`181`	`void ApplyBlock::got_cur_state(td::Ref<ShardState> state) {`
`174`		`- VLOG(VALIDATOR_DEBUG) << "apply block: received state for " << id_;`
	`182`	`+ VLOG(VALIDATOR_DEBUG) << "got_cur_state";`
`175`	`183`	`state_ = std::move(state);`
`176`	`184`	`CHECK(handle_->received_state());`
`177`	`185`	`written_state();`
`178`	`186`	`}`
`179`	`187`
`180`	`188`	`void ApplyBlock::written_state() {`
	`189`	`+ VLOG(VALIDATOR_DEBUG) << "written_state";`
`181`	`190`	`if (handle_->is_applied() && handle_->processed()) {`
`182`	`191`	`finish_query();`
`183`	`192`	`return;`
`184`	`193`	`}`
`185`		`- VLOG(VALIDATOR_DEBUG) << "apply block: setting next for parents of " << id_;`
	`194`	`+ VLOG(VALIDATOR_DEBUG) << "setting next for parents";`
`186`	`195`
`187`	`196`	`if (handle_->id().id.seqno != 0 && !handle_->is_applied()) {`
`188`	`197`	`auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {`
`@@ -208,12 +217,13 @@ void ApplyBlock::written_state() {`
`208`	`217`	`}`
`209`	`218`
`210`	`219`	`void ApplyBlock::written_next() {`
	`220`	`+ VLOG(VALIDATOR_DEBUG) << "written_next";`
`211`	`221`	`if (handle_->is_applied() && handle_->processed()) {`
`212`	`222`	`finish_query();`
`213`	`223`	`return;`
`214`	`224`	`}`
`215`	`225`
`216`		`- VLOG(VALIDATOR_DEBUG) << "apply block: applying parents of " << id_;`
	`226`	`+ VLOG(VALIDATOR_DEBUG) << "applying parents";`
`217`	`227`
`218`	`228`	`if (handle_->id().id.seqno != 0 && !handle_->is_applied()) {`
`219`	`229`	`auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {`
`@@ -241,7 +251,8 @@ void ApplyBlock::written_next() {`
`241`	`251`	`}`
`242`	`252`
`243`	`253`	`void ApplyBlock::applied_prev() {`
`244`		`- VLOG(VALIDATOR_DEBUG) << "apply block: waiting manager's confirm for " << id_;`
	`254`	`+ VLOG(VALIDATOR_DEBUG) << "applying parents";`
	`255`	`+ VLOG(VALIDATOR_DEBUG) << "applied_prev, waiting manager's confirm";`
`245`	`256`	`if (!id_.is_masterchain()) {`
`246`	`257`	`handle_->set_masterchain_ref_block(masterchain_block_id_.seqno());`
`247`	`258`	`}`
`@@ -253,10 +264,11 @@ void ApplyBlock::applied_prev() {`
`253`	`264`	`}`
`254`	`265`	`});`
`255`	`266`	`td::actor::send_closure(manager_, &ValidatorManager::new_block, handle_, state_, std::move(P));`
	`267`	`+`
`256`	`268`	`}`
`257`	`269`
`258`	`270`	`void ApplyBlock::applied_set() {`
`259`		`- VLOG(VALIDATOR_DEBUG) << "apply block: setting apply bit for " << id_;`
	`271`	`+ VLOG(VALIDATOR_DEBUG) << "applied_set";`
`260`	`272`	`handle_->set_applied();`
`261`	`273`	`if (handle_->id().seqno() > 0) {`
`262`	`274`	`CHECK(handle_->handle_moved_to_archive());`
`@@ -270,6 +282,7 @@ void ApplyBlock::applied_set() {`
`270`	`282`	`td::actor::send_closure(SelfId, &ApplyBlock::finish_query);`
`271`	`283`	`}`
`272`	`284`	`});`
	`285`	`+ VLOG(VALIDATOR_DEBUG) << "flush handle";`
`273`	`286`	`handle_->flush(manager_, handle_, std::move(P));`
`274`	`287`	`} else {`
`275`	`288`	`finish_query();`
Original file line number	Diff line number	Diff line change
`@@ -229,9 +229,10 @@ void ValidatorManagerImpl::new_block_broadcast(BlockBroadcast broadcast, td::Pro`
`229`	`229`	`}`
`230`	`230`	`promise.set_result(std::move(R));`
`231`	`231`	`};`
`232`		`- td::actor::create_actor<ValidateBroadcast>("broadcast", std::move(broadcast), last_masterchain_block_handle_,`
`233`		`- last_masterchain_state_, last_known_key_block_handle_, actor_id(this),`
`234`		`- td::Timestamp::in(2.0), std::move(promise))`
	`232`	`+ BlockIdExt block_id = broadcast.block_id;`
	`233`	`+ td::actor::create_actor<ValidateBroadcast>(`
	`234`	`+ PSTRING() << "broadcast" << block_id.id.to_str(), std::move(broadcast), last_masterchain_block_handle_,`
	`235`	`+ last_masterchain_state_, last_known_key_block_handle_, actor_id(this), td::Timestamp::in(2.0), std::move(promise))`
`235`	`236`	`.release();`
`236`	`237`	`}`
`237`	`238`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,7 @@ void DownloadBlock::got_block_partial_proof(td::BufferSlice proof) {`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`void DownloadBlock::checked_block_proof() {`
`297`		`- VLOG(FULL_NODE_DEBUG) << "checked proof for " << block_id_;`
	`297`	`+ VLOG(FULL_NODE_DEBUG) << "checked proof for " << block_id_.to_str();`
`298`	`298`
`299`	`299`	`if (!handle_) {`
`300`	`300`	`CHECK(!short_);`