Check limits from config in BuildOutMsgQueueProof

Author: SpyCheese

validator/full-node-shard.cpp

@@ -706,14 +706,6 @@ void FullNodeShardImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNod
     return;
   }
   block::ImportedMsgQueueLimits limits{(td::uint32)query.limits_->max_bytes_, (td::uint32)query.limits_->max_msgs_};
-  if (limits.max_msgs > 512) {
-    promise.set_error(td::Status::Error("max_msgs is too big"));
-    return;
-  }
-  if (limits.max_bytes > (1 << 21)) {
-    promise.set_error(td::Status::Error("max_bytes is too big"));
-    return;
-  }
   FLOG(DEBUG) {
     sb << "Got query getOutMsgQueueProof to shard " << dst_shard.to_str() << " from blocks";
     for (const BlockIdExt &id : blocks) {

validator/impl/out-msg-queue-proof.cpp

@@ -528,11 +528,11 @@ void OutMsgQueueImporter::alarm() {
     td::remove_if(it->second.pending_entries,
                   [](const std::shared_ptr<CacheEntry>& entry) { return entry->done || entry->promises.empty(); });
     if (it->second.timeout.is_in_past()) {
-        if (it->second.pending_entries.empty()) {
-            it = small_cache_.erase(it);
-        } else {
-            ++it;
-        }
+      if (it->second.pending_entries.empty()) {
+        it = small_cache_.erase(it);
+      } else {
+        ++it;
+      }
     } else {
       alarm_timestamp().relax(it->second.timeout);
       ++it;
@@ -571,6 +571,33 @@ void BuildOutMsgQueueProof::abort_query(td::Status reason) {
 }
 
 void BuildOutMsgQueueProof::start_up() {
+  if (blocks_.size() > 16) {
+    abort_query(td::Status::Error("too many blocks"));
+    return;
+  }
+  td::actor::send_closure(manager_, &ValidatorManagerInterface::get_top_masterchain_state,
+                          [SelfId = actor_id(this)](td::Result<Ref<MasterchainState>> R) {
+                            if (R.is_error()) {
+                              td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::abort_query,
+                                                      R.move_as_error_prefix("failed to get masterchain state: "));
+                            } else {
+                              td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::got_masterchain_state,
+                                                      R.move_as_ok());
+                            }
+                          });
+}
+
+void BuildOutMsgQueueProof::got_masterchain_state(Ref<MasterchainState> mc_state) {
+  auto config_limits = mc_state->get_imported_msg_queue_limits(dst_shard_.is_masterchain());
+  if ((td::uint64)config_limits.max_msgs * blocks_.size() < limits_.max_msgs) {
+    abort_query(td::Status::Error("too big max_msgs"));
+    return;
+  }
+  if ((td::uint64)config_limits.max_bytes * blocks_.size() < limits_.max_bytes) {
+    abort_query(td::Status::Error("too big max_bytes"));
+    return;
+  }
+
   for (size_t i = 0; i < blocks_.size(); ++i) {
     BlockIdExt id = blocks_[i].id;
     ++pending;

validator/impl/out-msg-queue-proof.hpp

@@ -105,6 +105,7 @@ class BuildOutMsgQueueProof : public td::actor::Actor {
 
   void abort_query(td::Status reason);
   void start_up() override;
+  void got_masterchain_state(Ref<MasterchainState> mc_state);
   void got_state_root(size_t i, Ref<vm::Cell> root);
   void got_block_root(size_t i, Ref<vm::Cell> root);
   void build_proof();