Ton

1
/*
2
    This file is part of TON Blockchain Library.
3

4
    TON Blockchain Library is free software: you can redistribute it and/or modify
5
    it under the terms of the GNU Lesser General Public License as published by
6
    the Free Software Foundation, either version 2 of the License, or
7
    (at your option) any later version.
8

9
    TON Blockchain Library is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU Lesser General Public License for more details.
13

14
    You should have received a copy of the GNU Lesser General Public License
15
    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
16
*/
17
#include "full-node-private-overlay.hpp"
18
#include "ton/ton-tl.hpp"
19
#include "common/delay.h"
20
#include "common/checksum.h"
21
#include "full-node-serializer.hpp"
22

23
namespace ton::validator::fullnode {
24

25
void FullNodePrivateBlockOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
26
  process_block_broadcast(src, query);
27
}
28

29
void FullNodePrivateBlockOverlay::process_broadcast(PublicKeyHash src,
30
                                                    ton_api::tonNode_blockBroadcastCompressed &query) {
31
  process_block_broadcast(src, query);
32
}
33

34
void FullNodePrivateBlockOverlay::process_block_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
35
  auto B = deserialize_block_broadcast(query, overlay::Overlays::max_fec_broadcast_size());
36
  if (B.is_error()) {
37
    LOG(DEBUG) << "dropped broadcast: " << B.move_as_error();
38
    return;
39
  }
40
  VLOG(FULL_NODE_DEBUG) << "Received block broadcast in private overlay from " << src << ": "
41
                        << B.ok().block_id.to_str();
42
  td::actor::send_closure(full_node_, &FullNode::process_block_broadcast, B.move_as_ok());
43
}
44

45
void FullNodePrivateBlockOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_newShardBlockBroadcast &query) {
46
  BlockIdExt block_id = create_block_id(query.block_->block_);
47
  VLOG(FULL_NODE_DEBUG) << "Received newShardBlockBroadcast in private overlay from " << src << ": "
48
                        << block_id.to_str();
49
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::new_shard_block, block_id,
50
                          query.block_->cc_seqno_, std::move(query.block_->data_));
51
}
52

53
void FullNodePrivateBlockOverlay::process_broadcast(PublicKeyHash src,
54
                                                    ton_api::tonNode_newBlockCandidateBroadcast &query) {
55
  process_block_candidate_broadcast(src, query);
56
}
57

58
void FullNodePrivateBlockOverlay::process_broadcast(PublicKeyHash src,
59
                                                    ton_api::tonNode_newBlockCandidateBroadcastCompressed &query) {
60
  process_block_candidate_broadcast(src, query);
61
}
62

63
void FullNodePrivateBlockOverlay::process_block_candidate_broadcast(PublicKeyHash src,
64
                                                                    ton_api::tonNode_Broadcast &query) {
65
  BlockIdExt block_id;
66
  CatchainSeqno cc_seqno;
67
  td::uint32 validator_set_hash;
68
  td::BufferSlice data;
69
  auto S = deserialize_block_candidate_broadcast(query, block_id, cc_seqno, validator_set_hash, data,
70
                                                 overlay::Overlays::max_fec_broadcast_size());
71
  if (S.is_error()) {
72
    LOG(DEBUG) << "dropped broadcast: " << S;
73
    return;
74
  }
75
  if (data.size() > FullNode::max_block_size()) {
76
    VLOG(FULL_NODE_WARNING) << "received block candidate with too big size from " << src;
77
    return;
78
  }
79
  if (td::sha256_bits256(data.as_slice()) != block_id.file_hash) {
80
    VLOG(FULL_NODE_WARNING) << "received block candidate with incorrect file hash from " << src;
81
    return;
82
  }
83
  VLOG(FULL_NODE_DEBUG) << "Received newBlockCandidate in private overlay from " << src << ": " << block_id.to_str();
84
  td::actor::send_closure(full_node_, &FullNode::process_block_candidate_broadcast, block_id, cc_seqno,
85
                          validator_set_hash, std::move(data));
86
}
87

88
void FullNodePrivateBlockOverlay::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) {
89
  if (adnl::AdnlNodeIdShort{src} == local_id_) {
90
    return;
91
  }
92
  auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true);
93
  if (B.is_error()) {
94
    return;
95
  }
96
  ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); });
97
}
98

99
void FullNodePrivateBlockOverlay::send_shard_block_info(BlockIdExt block_id, CatchainSeqno cc_seqno,
100
                                                        td::BufferSlice data) {
101
  if (!inited_) {
102
    return;
103
  }
104
  VLOG(FULL_NODE_DEBUG) << "Sending newShardBlockBroadcast in private overlay: " << block_id.to_str();
105
  auto B = create_serialize_tl_object<ton_api::tonNode_newShardBlockBroadcast>(
106
      create_tl_object<ton_api::tonNode_newShardBlock>(create_tl_block_id(block_id), cc_seqno, std::move(data)));
107
  if (B.size() <= overlay::Overlays::max_simple_broadcast_size()) {
108
    td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_ex, local_id_, overlay_id_,
109
                            local_id_.pubkey_hash(), 0, std::move(B));
110
  } else {
111
    td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
112
                            local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), std::move(B));
113
  }
114
}
115

116
void FullNodePrivateBlockOverlay::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_seqno,
117
                                                       td::uint32 validator_set_hash, td::BufferSlice data) {
118
  if (!inited_) {
119
    return;
120
  }
121
  auto B =
122
      serialize_block_candidate_broadcast(block_id, cc_seqno, validator_set_hash, data, true);  // compression enabled
123
  if (B.is_error()) {
124
    VLOG(FULL_NODE_WARNING) << "failed to serialize block candidate broadcast: " << B.move_as_error();
125
    return;
126
  }
127
  VLOG(FULL_NODE_DEBUG) << "Sending newBlockCandidate in private overlay: " << block_id.to_str();
128
  td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
129
                          local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
130
}
131

132
void FullNodePrivateBlockOverlay::send_broadcast(BlockBroadcast broadcast) {
133
  if (!inited_) {
134
    return;
135
  }
136
  VLOG(FULL_NODE_DEBUG) << "Sending block broadcast in private overlay"
137
                        << (enable_compression_ ? " (with compression)" : "") << ": " << broadcast.block_id.to_str();
138
  auto B = serialize_block_broadcast(broadcast, enable_compression_);
139
  if (B.is_error()) {
140
    VLOG(FULL_NODE_WARNING) << "failed to serialize block broadcast: " << B.move_as_error();
141
    return;
142
  }
143
  td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
144
                          local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
145
}
146

147
void FullNodePrivateBlockOverlay::start_up() {
148
  std::sort(nodes_.begin(), nodes_.end());
149
  nodes_.erase(std::unique(nodes_.begin(), nodes_.end()), nodes_.end());
150

151
  std::vector<td::Bits256> nodes;
152
  for (const adnl::AdnlNodeIdShort &id : nodes_) {
153
    nodes.push_back(id.bits256_value());
154
  }
155
  auto X = create_hash_tl_object<ton_api::tonNode_privateBlockOverlayId>(zero_state_file_hash_, std::move(nodes));
156
  td::BufferSlice b{32};
157
  b.as_slice().copy_from(as_slice(X));
158
  overlay_id_full_ = overlay::OverlayIdFull{std::move(b)};
159
  overlay_id_ = overlay_id_full_.compute_short_id();
160

161
  try_init();
162
}
163

164
void FullNodePrivateBlockOverlay::try_init() {
165
  // Sometimes adnl id is added to validator engine later (or not at all)
166
  td::actor::send_closure(
167
      adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) {
168
        if (R.is_ok() && R.ok()) {
169
          td::actor::send_closure(SelfId, &FullNodePrivateBlockOverlay::init);
170
        } else {
171
          delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodePrivateBlockOverlay::try_init); },
172
                       td::Timestamp::in(30.0));
173
        }
174
      });
175
}
176

177
void FullNodePrivateBlockOverlay::init() {
178
  LOG(FULL_NODE_WARNING) << "Creating private block overlay for adnl id " << local_id_ << " : " << nodes_.size()
179
                         << " nodes, overlay_id=" << overlay_id_;
180
  class Callback : public overlay::Overlays::Callback {
181
   public:
182
    void receive_message(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
183
    }
184
    void receive_query(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
185
                       td::Promise<td::BufferSlice> promise) override {
186
    }
187
    void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
188
      td::actor::send_closure(node_, &FullNodePrivateBlockOverlay::receive_broadcast, src, std::move(data));
189
    }
190
    void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
191
                         td::Promise<td::Unit> promise) override {
192
    }
193
    Callback(td::actor::ActorId<FullNodePrivateBlockOverlay> node) : node_(node) {
194
    }
195

196
   private:
197
    td::actor::ActorId<FullNodePrivateBlockOverlay> node_;
198
  };
199

200
  overlay::OverlayPrivacyRules rules{overlay::Overlays::max_fec_broadcast_size(),
201
                                     overlay::CertificateFlags::AllowFec | overlay::CertificateFlags::Trusted,
202
                                     {}};
203
  td::actor::send_closure(overlays_, &overlay::Overlays::create_private_overlay, local_id_, overlay_id_full_.clone(),
204
                          nodes_, std::make_unique<Callback>(actor_id(this)), rules, R"({ "type": "private-blocks" })");
205

206
  td::actor::send_closure(rldp_, &rldp::Rldp::add_id, local_id_);
207
  td::actor::send_closure(rldp2_, &rldp2::Rldp::add_id, local_id_);
208
  inited_ = true;
209
}
210

211
void FullNodePrivateBlockOverlay::tear_down() {
212
  if (inited_) {
213
    td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
214
  }
215
}
216

217
void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
218
  process_block_broadcast(src, query);
219
}
220

221
void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcastCompressed &query) {
222
  process_block_broadcast(src, query);
223
}
224

225
void FullNodeCustomOverlay::process_block_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
226
  if (!block_senders_.count(adnl::AdnlNodeIdShort(src))) {
227
    VLOG(FULL_NODE_DEBUG) << "Dropping block broadcast in private overlay \"" << name_ << "\" from unauthorized sender "
228
                          << src;
229
    return;
230
  }
231
  auto B = deserialize_block_broadcast(query, overlay::Overlays::max_fec_broadcast_size());
232
  if (B.is_error()) {
233
    LOG(DEBUG) << "dropped broadcast: " << B.move_as_error();
234
    return;
235
  }
236
  VLOG(FULL_NODE_DEBUG) << "Received block broadcast in custom overlay \"" << name_ << "\" from " << src << ": "
237
                        << B.ok().block_id.to_str();
238
  td::actor::send_closure(full_node_, &FullNode::process_block_broadcast, B.move_as_ok());
239
}
240

241
void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_externalMessageBroadcast &query) {
242
  auto it = msg_senders_.find(adnl::AdnlNodeIdShort{src});
243
  if (it == msg_senders_.end()) {
244
    VLOG(FULL_NODE_DEBUG) << "Dropping external message broadcast in custom overlay \"" << name_
245
                          << "\" from unauthorized sender " << src;
246
    return;
247
  }
248
  VLOG(FULL_NODE_DEBUG) << "Got external message in custom overlay \"" << name_ << "\" from " << src
249
                        << " (priority=" << it->second << ")";
250
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::new_external_message,
251
                          std::move(query.message_->data_), it->second);
252
}
253

254
void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcast &query) {
255
  process_block_candidate_broadcast(src, query);
256
}
257

258
void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src,
259
                                              ton_api::tonNode_newBlockCandidateBroadcastCompressed &query) {
260
  process_block_candidate_broadcast(src, query);
261
}
262

263
void FullNodeCustomOverlay::process_block_candidate_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
264
  if (!block_senders_.count(adnl::AdnlNodeIdShort(src))) {
265
    VLOG(FULL_NODE_DEBUG) << "Dropping block candidate broadcast in private overlay \"" << name_
266
                          << "\" from unauthorized sender " << src;
267
    return;
268
  }
269
  BlockIdExt block_id;
270
  CatchainSeqno cc_seqno;
271
  td::uint32 validator_set_hash;
272
  td::BufferSlice data;
273
  auto S = deserialize_block_candidate_broadcast(query, block_id, cc_seqno, validator_set_hash, data,
274
                                                 overlay::Overlays::max_fec_broadcast_size());
275
  if (S.is_error()) {
276
    LOG(DEBUG) << "dropped broadcast: " << S;
277
    return;
278
  }
279
  if (data.size() > FullNode::max_block_size()) {
280
    VLOG(FULL_NODE_WARNING) << "received block candidate with too big size from " << src;
281
    return;
282
  }
283
  if (td::sha256_bits256(data.as_slice()) != block_id.file_hash) {
284
    VLOG(FULL_NODE_WARNING) << "received block candidate with incorrect file hash from " << src;
285
    return;
286
  }
287
  VLOG(FULL_NODE_DEBUG) << "Received newBlockCandidate in custom overlay \"" << name_ << "\" from " << src << ": "
288
                        << block_id.to_str();
289
  td::actor::send_closure(full_node_, &FullNode::process_block_candidate_broadcast, block_id, cc_seqno,
290
                          validator_set_hash, std::move(data));
291
}
292

293
void FullNodeCustomOverlay::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) {
294
  if (adnl::AdnlNodeIdShort{src} == local_id_) {
295
    return;
296
  }
297
  auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true);
298
  if (B.is_error()) {
299
    return;
300
  }
301
  ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); });
302
}
303

304
void FullNodeCustomOverlay::send_external_message(td::BufferSlice data) {
305
  if (!inited_ || config_.ext_messages_broadcast_disabled_) {
306
    return;
307
  }
308
  VLOG(FULL_NODE_DEBUG) << "Sending external message to custom overlay \"" << name_ << "\"";
309
  auto B = create_serialize_tl_object<ton_api::tonNode_externalMessageBroadcast>(
310
      create_tl_object<ton_api::tonNode_externalMessage>(std::move(data)));
311
  if (B.size() <= overlay::Overlays::max_simple_broadcast_size()) {
312
    td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_ex, local_id_, overlay_id_,
313
                            local_id_.pubkey_hash(), 0, std::move(B));
314
  } else {
315
    td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
316
                            local_id_.pubkey_hash(), 0, std::move(B));
317
  }
318
}
319

320
void FullNodeCustomOverlay::send_broadcast(BlockBroadcast broadcast) {
321
  if (!inited_) {
322
    return;
323
  }
324
  VLOG(FULL_NODE_DEBUG) << "Sending block broadcast to custom overlay \"" << name_
325
                        << "\": " << broadcast.block_id.to_str();
326
  auto B = serialize_block_broadcast(broadcast, true);  // compression_enabled = true
327
  if (B.is_error()) {
328
    VLOG(FULL_NODE_WARNING) << "failed to serialize block broadcast: " << B.move_as_error();
329
    return;
330
  }
331
  td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
332
                          local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
333
}
334

335
void FullNodeCustomOverlay::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_seqno,
336
                                                 td::uint32 validator_set_hash, td::BufferSlice data) {
337
  if (!inited_) {
338
    return;
339
  }
340
  auto B =
341
      serialize_block_candidate_broadcast(block_id, cc_seqno, validator_set_hash, data, true);  // compression enabled
342
  if (B.is_error()) {
343
    VLOG(FULL_NODE_WARNING) << "failed to serialize block candidate broadcast: " << B.move_as_error();
344
    return;
345
  }
346
  VLOG(FULL_NODE_DEBUG) << "Sending newBlockCandidate in custom overlay \"" << name_ << "\": " << block_id.to_str();
347
  td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
348
                          local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
349
}
350

351
void FullNodeCustomOverlay::start_up() {
352
  std::sort(nodes_.begin(), nodes_.end());
353
  nodes_.erase(std::unique(nodes_.begin(), nodes_.end()), nodes_.end());
354
  std::vector<td::Bits256> nodes;
355
  for (const adnl::AdnlNodeIdShort &id : nodes_) {
356
    nodes.push_back(id.bits256_value());
357
  }
358
  auto X = create_hash_tl_object<ton_api::tonNode_customOverlayId>(zero_state_file_hash_, name_, std::move(nodes));
359
  td::BufferSlice b{32};
360
  b.as_slice().copy_from(as_slice(X));
361
  overlay_id_full_ = overlay::OverlayIdFull{std::move(b)};
362
  overlay_id_ = overlay_id_full_.compute_short_id();
363
  try_init();
364
}
365

366
void FullNodeCustomOverlay::try_init() {
367
  // Sometimes adnl id is added to validator engine later (or not at all)
368
  td::actor::send_closure(
369
      adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) {
370
        if (R.is_ok() && R.ok()) {
371
          td::actor::send_closure(SelfId, &FullNodeCustomOverlay::init);
372
        } else {
373
          delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodeCustomOverlay::try_init); },
374
                       td::Timestamp::in(30.0));
375
        }
376
      });
377
}
378

379
void FullNodeCustomOverlay::init() {
380
  LOG(FULL_NODE_WARNING) << "Creating custom overlay \"" << name_ << "\" for adnl id " << local_id_ << " : "
381
                         << nodes_.size() << " nodes, " << msg_senders_.size() << " msg senders, "
382
                         << block_senders_.size() << " block senders, overlay_id=" << overlay_id_;
383
  class Callback : public overlay::Overlays::Callback {
384
   public:
385
    void receive_message(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
386
    }
387
    void receive_query(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
388
                       td::Promise<td::BufferSlice> promise) override {
389
    }
390
    void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
391
      td::actor::send_closure(node_, &FullNodeCustomOverlay::receive_broadcast, src, std::move(data));
392
    }
393
    void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
394
                         td::Promise<td::Unit> promise) override {
395
    }
396
    Callback(td::actor::ActorId<FullNodeCustomOverlay> node) : node_(node) {
397
    }
398

399
   private:
400
    td::actor::ActorId<FullNodeCustomOverlay> node_;
401
  };
402

403
  std::map<PublicKeyHash, td::uint32> authorized_keys;
404
  for (const auto &sender : msg_senders_) {
405
    authorized_keys[sender.first.pubkey_hash()] = overlay::Overlays::max_fec_broadcast_size();
406
  }
407
  for (const auto &sender : block_senders_) {
408
    authorized_keys[sender.pubkey_hash()] = overlay::Overlays::max_fec_broadcast_size();
409
  }
410
  overlay::OverlayPrivacyRules rules{overlay::Overlays::max_fec_broadcast_size(), 0, std::move(authorized_keys)};
411
  td::actor::send_closure(
412
      overlays_, &overlay::Overlays::create_private_overlay, local_id_, overlay_id_full_.clone(), nodes_,
413
      std::make_unique<Callback>(actor_id(this)), rules,
414
      PSTRING() << R"({ "type": "custom-overlay", "name": ")" << td::format::Escaped{name_} << R"(" })");
415

416
  td::actor::send_closure(rldp_, &rldp::Rldp::add_id, local_id_);
417
  td::actor::send_closure(rldp2_, &rldp2::Rldp::add_id, local_id_);
418
  inited_ = true;
419
}
420

421
void FullNodeCustomOverlay::tear_down() {
422
  LOG(FULL_NODE_WARNING) << "Destroying custom overlay \"" << name_ << "\" for adnl id " << local_id_;
423
  td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
424
}
425

426
}  // namespace ton::validator::fullnode
427