Add "self" to all session stats records

tl/generate/scheme/ton_api.tl

@@ -923,30 +923,31 @@ validatorStats.blockLimitsStatus
 validatorStats.extMsgsStats
     ext_msgs_total:int ext_msgs_filtered:int ext_msgs_accepted:int ext_msgs_rejected:int = validatorStats.ExtMsgsStats;
 
-validatorStats.collatedBlock flags:#
+validatorStats.collatedBlock
     block_id:tonNode.blockIdExt collated_data_hash:int256 cc_seqno:int collated_at:double
     bytes:int collated_data_bytes:int attempt:int
-    collator_node_id:flags.0?int256 validator_id:flags.1?int256
+    self:int256 is_validator:Bool
     total_time:double work_time:double cpu_work_time:double time_stats:string
     block_limits:validatorStats.blockLimitsStatus
     ext_msgs_stats:validatorStats.extMsgsStats = validatorSession.stats.CollatedBlock;
 
 validatorStats.validatedBlock
     block_id:tonNode.blockIdExt collated_data_hash:int256 validated_at:double
+    self:int256
     valid:Bool comment:string
     bytes:int collated_data_bytes:int
     total_time:double work_time:double cpu_work_time:double = validatorStats.ValidatedBlock;
 
 validatorStats.newValidatorGroup.node id:int256 weight:long = validatorStats.newValidatorGroup.Node;
 validatorStats.newValidatorGroup session_id:int256 shard:tonNode.shardId cc_seqno:int
     last_key_block_seqno:int started_at:double
-    self_idx:int nodes:(vector validatorStats.newValidatorGroup.node) = validatorStats.NewValidatorGroup;
+    self_idx:int self:int256 nodes:(vector validatorStats.newValidatorGroup.node) = validatorStats.NewValidatorGroup;
 
 validatorStats.endValidatorGroup.node id:int256 catchain_blocks:int = validatorStats.endValidatorGroup.Node;
-validatorStats.endValidatorGroup session_id:int256 timestamp:double
+validatorStats.endValidatorGroup session_id:int256 timestamp:double self:int256
     nodes:(vector validatorStats.endValidatorGroup.node) = validatorStats.EndValidatorGroup;
 
-validatorStats.collatorNodeResponse collator_node_id:int256 validator_id:int256 timestamp:double
+validatorStats.collatorNodeResponse self:int256 validator_id:int256 timestamp:double
     block_id:tonNode.blockIdExt original_block_id:tonNode.blockIdExt collated_data_hash:int256
     = validatorStats.CollatorNodeResponse;
 

validator-session/validator-session-types.h

@@ -222,6 +222,7 @@ struct NewValidatorGroupStats {
   BlockSeqno last_key_block_seqno = 0;
   double started_at = -1.0;
   td::uint32 self_idx = 0;
+  PublicKeyHash self = PublicKeyHash::zero();
   std::vector<Node> nodes;
 
   tl_object_ptr<ton_api::validatorStats_newValidatorGroup> tl() const {
@@ -232,7 +233,7 @@ struct NewValidatorGroupStats {
     }
     return create_tl_object<ton_api::validatorStats_newValidatorGroup>(session_id, create_tl_shard_id(shard), cc_seqno,
                                                                        last_key_block_seqno, started_at, self_idx,
-                                                                       std::move(nodes_arr));
+                                                                       self.bits256_value(), std::move(nodes_arr));
   }
 };
 
@@ -244,6 +245,7 @@ struct EndValidatorGroupStats {
 
   ValidatorSessionId session_id = ValidatorSessionId::zero();
   double timestamp = -1.0;
+  PublicKeyHash self = PublicKeyHash::zero();
   std::vector<Node> nodes;
 
   tl_object_ptr<ton_api::validatorStats_endValidatorGroup> tl() const {
@@ -252,7 +254,8 @@ struct EndValidatorGroupStats {
       nodes_arr.push_back(create_tl_object<ton_api::validatorStats_endValidatorGroup_node>(node.id.bits256_value(),
                                                                                            node.catchain_blocks));
     }
-    return create_tl_object<ton_api::validatorStats_endValidatorGroup>(session_id, timestamp, std::move(nodes_arr));
+    return create_tl_object<ton_api::validatorStats_endValidatorGroup>(session_id, timestamp, self.bits256_value(),
+                                                                       std::move(nodes_arr));
   }
 };
 

validator-session/validator-session.cpp

@@ -1036,7 +1036,7 @@ void ValidatorSessionImpl::get_end_stats(td::Promise<EndValidatorGroupStats> pro
     promise.set_error(td::Status::Error(ErrorCode::notready, "not started"));
     return;
   }
-  EndValidatorGroupStats stats{.session_id = unique_hash_, .timestamp = td::Clocks::system()};
+  EndValidatorGroupStats stats{.session_id = unique_hash_, .timestamp = td::Clocks::system(), .self = local_id()};
   stats.nodes.resize(description().get_total_nodes());
   for (size_t i = 0; i < stats.nodes.size(); ++i) {
     stats.nodes[i].id = description().get_source_id(i);

validator/collator-node.cpp

@@ -396,8 +396,8 @@ void CollatorNode::receive_query(adnl::AdnlNodeIdShort src, td::BufferSlice data
     TRY_RESULT_PROMISE(new_promise, block, std::move(R));
 
     CollatorNodeResponseStats stats;
-    stats.collator_node_id = local_id.bits256_value();
-    stats.validator_id = creator.as_bits256();
+    stats.self = local_id.pubkey_hash();
+    stats.validator_id = PublicKey(pubkeys::Ed25519(creator)).compute_short_id();
     stats.original_block_id = block.id;
     stats.collated_data_hash = block.collated_file_hash;
 

validator/fabric.h

@@ -82,7 +82,7 @@ void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::Actor
 void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::actor::ActorId<ValidatorManager> manager,
                                 td::Timestamp timeout, td::Promise<BlockHandle> promise);
 void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                        BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
+                        BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
 void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,

validator/impl/collator.cpp

@@ -5936,8 +5936,9 @@ bool Collator::create_block_candidate() {
   stats_.actual_bytes = block_candidate->data.size();
   stats_.actual_collated_data_bytes = block_candidate->collated_data.size();
   stats_.attempt = attempt_idx_;
-  stats_.collator_node_id = collator_node_id_.bits256_value();
-  stats_.validator_id = created_by_.as_bits256();
+  stats_.is_validator = !(mode_ & CollateMode::from_collator_node);
+  stats_.self = stats_.is_validator ? PublicKey(pubkeys::Ed25519(created_by_)).compute_short_id()
+                                    : collator_node_id_.pubkey_hash();
   stats_.estimated_bytes = block_limit_status_->estimate_block_size();
   stats_.gas = block_limit_status_->gas_used;
   stats_.lt_delta = block_limit_status_->cur_lt - block_limit_status_->limits.start_lt;

validator/impl/fabric.cpp

@@ -192,8 +192,8 @@ void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::act
       .release();
 }
 
-void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
-                        std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
+void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
+                        BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode) {
   BlockSeqno seqno = 0;
@@ -207,8 +207,8 @@ void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
   td::actor::create_actor<ValidateQuery>(PSTRING() << (is_fake ? "fakevalidate" : "validateblock") << shard.to_str()
                                                    << ":" << (seqno + 1) << "#" << idx.fetch_add(1),
                                          shard, min_masterchain_block_id, std::move(prev), std::move(candidate),
-                                         std::move(validator_set), std::move(manager), timeout, std::move(promise),
-                                         mode)
+                                         std::move(validator_set), local_validator_id, std::move(manager), timeout,
+                                         std::move(promise), mode)
       .release();
 }
 

validator/impl/validate-query.cpp

@@ -67,16 +67,17 @@ std::string ErrorCtx::as_string() const {
  * @param promise The Promise to return the ValidateCandidateResult to.
  * @param mode +1 - fake mode
  */
-ValidateQuery::ValidateQuery(ShardIdFull shard, 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, unsigned mode)
+ValidateQuery::ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
+                             BlockCandidate candidate, Ref<ValidatorSet> validator_set,
+                             PublicKeyHash local_validator_id, td::actor::ActorId<ValidatorManager> manager,
+                             td::Timestamp timeout, td::Promise<ValidateCandidateResult> promise, unsigned mode)
     : shard_(shard)
     , id_(candidate.id)
     , min_mc_block_id(min_masterchain_block_id)
     , prev_blocks(std::move(prev))
     , block_candidate(std::move(candidate))
     , validator_set_(std::move(validator_set))
+    , local_validator_id_(local_validator_id)
     , manager(manager)
     , timeout(timeout)
     , main_promise(std::move(promise))
@@ -7062,6 +7063,7 @@ void ValidateQuery::record_stats(bool valid, std::string error_message) {
   stats.block_id = id_;
   stats.collated_data_hash = block_candidate.collated_file_hash;
   stats.validated_at = td::Clocks::system();
+  stats.self = local_validator_id_;
   stats.valid = valid;
   if (valid) {
     stats.comment = (PSTRING() << "OK ts=" << now_);

validator/impl/validate-query.hpp

@@ -118,7 +118,7 @@ class ValidateQuery : public td::actor::Actor {
 
  public:
   ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
+                BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
                 td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                 td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
 
@@ -132,6 +132,7 @@ class ValidateQuery : public td::actor::Actor {
   std::vector<Ref<ShardState>> prev_states;
   BlockCandidate block_candidate;
   td::Ref<ValidatorSet> validator_set_;
+  PublicKeyHash local_validator_id_ = PublicKeyHash::zero();
   td::actor::ActorId<ValidatorManager> manager;
   td::Timestamp timeout;
   td::Promise<ValidateCandidateResult> main_promise;

validator/interfaces/validator-manager.h

@@ -62,8 +62,8 @@ struct CollationStats {
   double collated_at = -1.0;
   td::uint32 actual_bytes = 0, actual_collated_data_bytes = 0;
   int attempt = 0;
-  td::Bits256 collator_node_id = td::Bits256::zero();
-  td::Bits256 validator_id = td::Bits256::zero();
+  PublicKeyHash self = PublicKeyHash::zero();
+  bool is_validator = false;
   td::uint32 estimated_bytes = 0, gas = 0, lt_delta = 0, estimated_collated_data_bytes = 0;
   int cat_bytes = 0, cat_gas = 0, cat_lt_delta = 0, cat_collated_data_bytes = 0;
   std::string limits_log;
@@ -75,11 +75,9 @@ struct CollationStats {
   std::string time_stats;
 
   tl_object_ptr<ton_api::validatorStats_collatedBlock> tl() const {
-    int flags = (collator_node_id.is_zero() ? 0 : ton_api::validatorStats_collatedBlock::Flags::COLLATOR_NODE_ID_MASK) |
-                (validator_id.is_zero() ? 0 : ton_api::validatorStats_collatedBlock::Flags::VALIDATOR_ID_MASK);
     return create_tl_object<ton_api::validatorStats_collatedBlock>(
-        flags, create_tl_block_id(block_id), collated_data_hash, cc_seqno, collated_at, actual_bytes,
-        actual_collated_data_bytes, attempt, collator_node_id, validator_id, total_time, work_time, cpu_work_time,
+        create_tl_block_id(block_id), collated_data_hash, cc_seqno, collated_at, actual_bytes,
+        actual_collated_data_bytes, attempt, self.bits256_value(), is_validator, total_time, work_time, cpu_work_time,
         time_stats,
         create_tl_object<ton_api::validatorStats_blockLimitsStatus>(estimated_bytes, gas, lt_delta,
                                                                     estimated_collated_data_bytes, cat_bytes, cat_gas,
@@ -93,29 +91,31 @@ struct ValidationStats {
   BlockIdExt block_id;
   td::Bits256 collated_data_hash = td::Bits256::zero();
   double validated_at = -1.0;
+  PublicKeyHash self = PublicKeyHash::zero();
   bool valid = false;
   std::string comment;
   td::uint32 actual_bytes = 0, actual_collated_data_bytes = 0;
   double total_time = 0.0, work_time = 0.0, cpu_work_time = 0.0;
 
   tl_object_ptr<ton_api::validatorStats_validatedBlock> tl() const {
     return create_tl_object<ton_api::validatorStats_validatedBlock>(
-        create_tl_block_id(block_id), collated_data_hash, validated_at, valid, comment, actual_bytes,
-        actual_collated_data_bytes, total_time, work_time, cpu_work_time);
+        create_tl_block_id(block_id), collated_data_hash, validated_at, self.bits256_value(), valid, comment,
+        actual_bytes, actual_collated_data_bytes, total_time, work_time, cpu_work_time);
   }
 };
 
 struct CollatorNodeResponseStats {
-  td::Bits256 collator_node_id = td::Bits256::zero();
-  td::Bits256 validator_id = td::Bits256::zero();
+  PublicKeyHash self = PublicKeyHash::zero();
+  PublicKeyHash validator_id = PublicKeyHash::zero();
   double timestamp = -1.0;
   BlockIdExt block_id, original_block_id;
   td::Bits256 collated_data_hash = td::Bits256::zero();
 
   tl_object_ptr<ton_api::validatorStats_collatorNodeResponse> tl() const {
     return create_tl_object<ton_api::validatorStats_collatorNodeResponse>(
-        collator_node_id, validator_id, timestamp, create_tl_block_id(block_id), create_tl_block_id(original_block_id),
-        collated_data_hash);;
+        self.bits256_value(), validator_id.bits256_value(), timestamp, create_tl_block_id(block_id),
+        create_tl_block_id(original_block_id), collated_data_hash);
+    ;
   }
 };
 

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, last, prev, std::move(candidate), std::move(val_set), actor_id(this),
+  run_validate_query(shard, last, prev, std::move(candidate), std::move(val_set), PublicKeyHash::zero(), actor_id(this),
                      td::Timestamp::in(10.0), std::move(P), ValidateMode::fake);
 }
 

validator/validator-group.cpp

@@ -155,8 +155,8 @@ void ValidatorGroup::validate_block_candidate(validatorsession::BlockSourceInfo
     return;
   }
   VLOG(VALIDATOR_DEBUG) << "validating block candidate " << next_block_id;
-  run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_, manager_,
-                     td::Timestamp::in(15.0), std::move(P));
+  run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_,
+                     local_id_, manager_, td::Timestamp::in(15.0), std::move(P));
 }
 
 void ValidatorGroup::update_approve_cache(CacheKey key, UnixTime value) {
@@ -413,7 +413,8 @@ void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterch
                                                  .shard = shard_,
                                                  .cc_seqno = validator_set_->get_catchain_seqno(),
                                                  .last_key_block_seqno = last_key_block_seqno_,
-                                                 .started_at = td::Clocks::system()};
+                                                 .started_at = td::Clocks::system(),
+                                                 .self = local_id_};
   td::uint32 idx = 0;
   for (const auto &node : validator_set_->export_vector()) {
     PublicKeyHash id = ValidatorFullId{node.key}.compute_short_id();