Merge branch 'testnet' into accelerator

tonlib/tonlib/TonlibClient.cpp

@@ -5560,6 +5560,11 @@ td::Status TonlibClient::do_request(const tonlib_api::blocks_lookupBlock& reques
   client_.with_last_block(
     [self = this, blkid, lite_block = std::move(lite_block), mode = request.mode_, lt = (td::uint64)request.lt_, 
     utime = (td::uint32)request.utime_, promise = std::move(promise)](td::Result<LastBlockState> r_last_block) mutable {
+      if (r_last_block.is_error()) {
+        promise.set_error(r_last_block.move_as_error_prefix(TonlibError::Internal("get last block failed ")));
+        return;
+      }
+
       self->client_.send_query(ton::lite_api::liteServer_lookupBlockWithProof(mode, std::move(lite_block), ton::create_tl_lite_block_id(r_last_block.ok().last_block_id), lt, utime),
         promise.wrap([blkid, mode, utime, lt, last_block = r_last_block.ok().last_block_id](lite_api_ptr<ton::lite_api::liteServer_lookupBlockResult>&& result)
                                           -> td::Result<object_ptr<tonlib_api::ton_blockIdExt>> {

validator/impl/collator-impl.h

@@ -221,6 +221,7 @@ class Collator final : public td::actor::Actor {
   unsigned dispatch_queue_ops_{0};
   std::map<StdSmcAddress, LogicalTime> last_dispatch_queue_emitted_lt_;
   bool have_unprocessed_account_dispatch_queue_ = false;
+  bool dispatch_queue_total_limit_reached_ = false;
   td::uint64 defer_out_queue_size_limit_;
   td::uint64 hard_defer_out_queue_size_limit_;
 

validator/impl/collator.cpp

@@ -3865,6 +3865,7 @@ bool Collator::process_dispatch_queue() {
       }
       ++total_count;
       if (total_count >= max_total_count[iter]) {
+        dispatch_queue_total_limit_reached_ = true;
         break;
       }
     }
@@ -4815,7 +4816,21 @@ bool Collator::check_block_overload() {
             << " size_estimate=" << block_size_estimate_
             << " collated_size_estimate=" << block_limit_status_->collated_data_stat.estimate_proof_size();
   auto cl = block_limit_status_->classify();
-  if (cl <= block::ParamLimits::cl_underload) {
+  if (cl >= block::ParamLimits::cl_soft || dispatch_queue_total_limit_reached_) {
+    std::string message = "block is overloaded ";
+    if (cl >= block::ParamLimits::cl_soft) {
+      message += PSTRING() << "(category " << cl << ")";
+    } else {
+      message += "(long dispatch queue processing)";
+    }
+    if (out_msg_queue_size_ > SPLIT_MAX_QUEUE_SIZE) {
+      LOG(INFO) << message << ", but don't set overload history because out_msg_queue size is too big to split ("
+                << out_msg_queue_size_ << " > " << SPLIT_MAX_QUEUE_SIZE << ")";
+    } else {
+      overload_history_ |= 1;
+      LOG(INFO) << message;
+    }
+  } else if (cl <= block::ParamLimits::cl_underload) {
     if (out_msg_queue_size_ > MERGE_MAX_QUEUE_SIZE) {
       LOG(INFO)
           << "block is underloaded, but don't set underload history because out_msg_queue size is too big to merge ("
@@ -4824,15 +4839,6 @@ bool Collator::check_block_overload() {
       underload_history_ |= 1;
       LOG(INFO) << "block is underloaded";
     }
-  } else if (cl >= block::ParamLimits::cl_soft) {
-    if (out_msg_queue_size_ > SPLIT_MAX_QUEUE_SIZE) {
-      LOG(INFO) << "block is overloaded (category " << cl
-                << "), but don't set overload history because out_msg_queue size is too big to split ("
-                << out_msg_queue_size_ << " > " << SPLIT_MAX_QUEUE_SIZE << ")";
-    } else {
-      overload_history_ |= 1;
-      LOG(INFO) << "block is overloaded (category " << cl << ")";
-    }
   } else {
     LOG(INFO) << "block is loaded normally";
   }

validator/manager.cpp

@@ -2064,8 +2064,10 @@ void ValidatorManagerImpl::new_masterchain_block() {
       last_known_key_block_handle_ = last_key_block_handle_;
       callback_->new_key_block(last_key_block_handle_);
     }
-    td::actor::send_closure(serializer_, &AsyncStateSerializer::update_last_known_key_block_ts,
+    if (!serializer_.empty()) {
-                            last_key_block_handle_->unix_time());
+      td::actor::send_closure(serializer_, &AsyncStateSerializer::update_last_known_key_block_ts,
+                              last_key_block_handle_->unix_time());
+    }
   }
 
   update_shard_overlays();