Remove unused get validator session stats query

tl/generate/scheme/ton_api.tl

@@ -712,10 +712,6 @@ engine.validator.perfTimerStats stats:(vector engine.validator.PerfTimerStatsByN
 
 engine.validator.shardOutQueueSize size:long = engine.validator.ShardOutQueueSize;
 
-engine.validator.validatorSessionInfo current_block:tonNode.blockId self:int256 current_round:int next_producers:(vector int256) = engine.validator.ValidatorSessionInfo;
-engine.validator.validatorSessionsInfo sessions:(vector engine.validator.validatorSessionInfo) = engine.validator.ValidatorSessionsInfo;
-
-engine.validator.requiredBlockCandidates block_ids:(vector tonNode.blockId) = engine.validator.RequiredBlockCandidates;
 
 ---functions---
 
@@ -779,8 +775,6 @@ engine.validator.setStateSerializerEnabled enabled:Bool = engine.validator.Succe
 engine.validator.setCollatorOptionsJson json:string = engine.validator.Success;
 engine.validator.getCollatorOptionsJson = engine.validator.JsonConfig;
 
-engine.validator.getValidatorSessionsInfo = engine.validator.ValidatorSessionsInfo;
-
 engine.validator.addCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;
 engine.validator.addShard shard:tonNode.shardId = engine.validator.Success;
 engine.validator.delCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;

validator-engine-console/validator-engine-console-query.cpp

@@ -1291,26 +1291,6 @@ td::Status GetCollatorOptionsJsonQuery::receive(td::BufferSlice data) {
   return td::Status::OK();
 }
 
-td::Status GetValidatorSessionsInfoQuery::run() {
-  TRY_STATUS(tokenizer_.check_endl());
-  return td::Status::OK();
-}
-
-td::Status GetValidatorSessionsInfoQuery::send() {
-  auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_getValidatorSessionsInfo>();
-  td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
-  return td::Status::OK();
-}
-
-td::Status GetValidatorSessionsInfoQuery::receive(td::BufferSlice data) {
-  TRY_RESULT_PREFIX(
-      f, ton::fetch_tl_object<ton::ton_api::engine_validator_validatorSessionsInfo>(data.as_slice(), true),
-      "received incorrect answer: ");
-  std::string s = td::json_encode<std::string>(td::ToJson(*f), true);
-  td::TerminalIO::out() << "---------\n" << s << "--------\n";
-  return td::Status::OK();
-}
-
 td::Status AddCollatorQuery::run() {
   TRY_RESULT_ASSIGN(adnl_id_, tokenizer_.get_token<ton::PublicKeyHash>());
   TRY_RESULT_ASSIGN(wc_, tokenizer_.get_token<td::int32>());

validator-engine-console/validator-engine-console-query.h

@@ -1293,25 +1293,6 @@ class GetCollatorOptionsJsonQuery : public Query {
   std::string file_name_;
 };
 
-class GetValidatorSessionsInfoQuery : public Query {
- public:
-  GetValidatorSessionsInfoQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
-      : Query(console, std::move(tokenizer)) {
-  }
-  td::Status run() override;
-  td::Status send() override;
-  td::Status receive(td::BufferSlice data) override;
-  static std::string get_name() {
-    return "getvalidatorsessions";
-  }
-  static std::string get_help() {
-    return "getvalidatorsessions\tprint info about validator session";
-  }
-  std::string name() const override {
-    return get_name();
-  }
-};
-
 class AddCollatorQuery : public Query {
  public:
   AddCollatorQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)

validator-engine-console/validator-engine-console.cpp

@@ -150,7 +150,6 @@ void ValidatorEngineConsole::run() {
   add_query_runner(std::make_unique<QueryRunnerImpl<SetCollatorOptionsJsonQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<ResetCollatorOptionsQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<GetCollatorOptionsJsonQuery>>());
-  add_query_runner(std::make_unique<QueryRunnerImpl<GetValidatorSessionsInfoQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<AddCollatorQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<AddShardQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<DelShardQuery>>());

validator-engine/validator-engine.cpp

@@ -4081,33 +4081,6 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_showColla
   }
 }
 
-void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &query,
-                                        td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
-                                        td::Promise<td::BufferSlice> promise) {
-  if (!(perm & ValidatorEnginePermissions::vep_default)) {
-    promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
-    return;
-  }
-
-  if (validator_manager_.empty()) {
-    promise.set_value(
-        create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "validator manager not started")));
-    return;
-  }
-
-  auto P = td::PromiseCreator::lambda(
-      [promise = std::move(promise)](
-          td::Result<ton::tl_object_ptr<ton::ton_api::engine_validator_validatorSessionsInfo>> R) mutable {
-        if (R.is_error()) {
-          promise.set_value(create_control_query_error(R.move_as_error()));
-        } else {
-          promise.set_value(ton::serialize_tl_object(R.move_as_ok(), true));
-        }
-      });
-  td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::get_validator_sessions_info,
-                          std::move(P));
-}
-
 void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCollator &query,
                                         td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
                                         td::Promise<td::BufferSlice> promise) {

validator-engine/validator-engine.hpp

@@ -504,8 +504,6 @@ class ValidatorEngine : public td::actor::Actor {
                          ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
   void run_control_query(ton::ton_api::engine_validator_getOverlaysStats &query, td::BufferSlice data,
                          ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
-  void run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &query, td::BufferSlice data,
-                         ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
   void run_control_query(ton::ton_api::engine_validator_addCollator &query, td::BufferSlice data,
                          ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
   void run_control_query(ton::ton_api::engine_validator_addShard &query, td::BufferSlice data,

validator-session/validator-session.cpp

@@ -1206,18 +1206,6 @@ void ValidatorSessionImpl::stats_process_action(td::uint32 node_id, ton_api::val
                                      [](const auto &) {}));
 }
 
-void ValidatorSessionImpl::get_session_info(
-    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
-  std::vector<td::Bits256> next_producers;
-  for (td::uint32 round = cur_round_; round < cur_round_ + 20; ++round) {
-    td::uint32 node = description().get_node_by_priority(round, 0);
-    next_producers.push_back(description().get_source_id(node).bits256_value());
-  }
-  promise.set_result(create_tl_object<ton_api::engine_validator_validatorSessionInfo>(
-      create_tl_block_id_simple(BlockId{}), description().get_source_id(local_idx()).bits256_value(),
-      cur_round_, std::move(next_producers)));
-}
-
 td::actor::ActorOwn<ValidatorSession> ValidatorSession::create(
     catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
     std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator-session/validator-session.h

@@ -110,8 +110,6 @@ class ValidatorSession : public td::actor::Actor {
       td::Promise<std::vector<tl_object_ptr<lite_api::liteServer_nonfinal_candidateInfo>>> promise) = 0;
   virtual void set_catchain_max_block_delay(double value) = 0;
 
-  virtual void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) = 0;
-
   static td::actor::ActorOwn<ValidatorSession> create(
       catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
       std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator-session/validator-session.hpp

@@ -175,8 +175,6 @@ class ValidatorSessionImpl : public ValidatorSession {
                                                                   ValidatorSessionCandidateId candidate_id);
   void stats_process_action(td::uint32 node_id, ton_api::validatorSession_round_Message &action);
 
-  void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) override;
-
  public:
   ValidatorSessionImpl(catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
                        std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator/manager-disk.hpp

@@ -441,11 +441,6 @@ class ValidatorManagerImpl : public ValidatorManager {
   void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override {
   }
 
-  void get_validator_sessions_info(
-      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
-    UNREACHABLE();
-  }
-
   void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
     UNREACHABLE();
   }

validator/manager-hardfork.hpp

@@ -506,10 +506,6 @@ class ValidatorManagerImpl : public ValidatorManager {
   }
   void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override {
   }
-  void get_validator_sessions_info(
-      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
-    UNREACHABLE();
-  }
 
   void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
     UNREACHABLE();

validator/manager.cpp

@@ -3394,39 +3394,6 @@ void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts)
   opts_ = std::move(opts);
 }
 
-void ValidatorManagerImpl::get_validator_sessions_info(
-    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) {
-  std::vector<td::actor::ActorId<ValidatorGroup>> groups;
-  for (const auto& g : validator_groups_) {
-    groups.push_back(g.second.actor.get());
-  }
-  struct IntermediateData {
-    std::vector<td::actor::ActorId<ValidatorGroup>> groups;
-    std::vector<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> result;
-    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise;
-
-    static void step(IntermediateData data) {
-      if (data.groups.empty()) {
-        data.promise.set_result(
-            create_tl_object<ton_api::engine_validator_validatorSessionsInfo>(std::move(data.result)));
-        return;
-      }
-      auto group = std::move(data.groups.back());
-      data.groups.pop_back();
-      auto P = td::PromiseCreator::lambda(
-          [data =
-               std::move(data)](td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
-            if (R.is_ok()) {
-              data.result.push_back(R.move_as_ok());
-            }
-            step(std::move(data));
-          });
-      td::actor::send_closure(group, &ValidatorGroup::get_session_info, std::move(P));
-    }
-  };
-  IntermediateData::step({std::move(groups), {}, std::move(promise)});
-}
-
 void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) {
   if (shard.is_masterchain() || !shard.is_valid_ext()) {
     LOG(WARNING) << "cannot collate shard " << shard.to_str();

validator/manager.hpp

@@ -622,9 +622,6 @@ class ValidatorManagerImpl : public ValidatorManager {
 
   void update_options(td::Ref<ValidatorManagerOptions> opts) override;
 
-  void get_validator_sessions_info(
-      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override;
-
   void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override;
 
   void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;

validator/validator-group.cpp

@@ -448,25 +448,6 @@ void ValidatorGroup::get_validator_group_info_for_litequery_cont(
   promise.set_result(std::move(result));
 }
 
-void ValidatorGroup::get_session_info(
-    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
-  if (session_.empty() || !started_) {
-    promise.set_error(td::Status::Error(ErrorCode::notready, "session not started"));
-  }
-  auto P = td::PromiseCreator::lambda(
-      [promise = std::move(promise), block_id = create_next_block_id_simple()](
-          td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
-        if (R.is_error()) {
-          promise.set_error(R.move_as_error());
-          return;
-        }
-        auto info = R.move_as_ok();
-        info->current_block_ = create_tl_block_id_simple(block_id);
-        promise.set_result(std::move(info));
-      });
-  td::actor::send_closure(session_, &validatorsession::ValidatorSession::get_session_info, std::move(P));
-}
-
 void ValidatorGroup::collate_block(td::uint32 round_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
                                    unsigned max_retries) {
   if (round_id < last_known_round_id_) {

validator/validator-group.hpp

@@ -64,8 +64,6 @@ class ValidatorGroup : public td::actor::Actor {
   void get_validator_group_info_for_litequery(
       td::Promise<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroupInfo>> promise);
 
-  void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise);
-
   void update_options(td::Ref<ValidatorManagerOptions> opts, bool apply_blocks) {
     opts_ = std::move(opts);
     monitoring_shard_ = apply_blocks;

validator/validator.h

@@ -302,9 +302,6 @@ class ValidatorManagerInterface : public td::actor::Actor {
 
   virtual void update_options(td::Ref<ValidatorManagerOptions> opts) = 0;
 
-  virtual void get_validator_sessions_info(
-      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) = 0;
-
   virtual void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
   virtual void del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
 };