/
Toncoin
/
Ton
GigaCode
beta
ОбзорЦентр заботыВойти

Ton

Форк
0
Ветки: 7Коммиты: 665Теги: 31
Ton
/validator
/
full-node-serializer.cpp 
214 строк · 11.6 Кб
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-serializer.hpp"
18
#include "ton/ton-tl.hpp"
19
#include "tl-utils/common-utils.hpp"
20
#include "auto/tl/ton_api.hpp"
21
#include "tl-utils/tl-utils.hpp"
22
#include "vm/boc.h"
23
#include "td/utils/lz4.h"
24
#include "full-node.h"
25
#include "td/utils/overloaded.h"
26


27
namespace ton::validator::fullnode {
28


29
td::Result<td::BufferSlice> serialize_block_broadcast(const BlockBroadcast& broadcast, bool compression_enabled) {
30
  std::vector<tl_object_ptr<ton_api::tonNode_blockSignature>> sigs;
31
  for (auto& sig : broadcast.signatures) {
32
    sigs.emplace_back(create_tl_object<ton_api::tonNode_blockSignature>(sig.node, sig.signature.clone()));
33
  }
34
  if (!compression_enabled) {
35
    return create_serialize_tl_object<ton_api::tonNode_blockBroadcast>(
36
        create_tl_block_id(broadcast.block_id), broadcast.catchain_seqno, broadcast.validator_set_hash, std::move(sigs),
37
        broadcast.proof.clone(), broadcast.data.clone());
38
  }
39


40
  TRY_RESULT(proof_root, vm::std_boc_deserialize(broadcast.proof));
41
  TRY_RESULT(data_root, vm::std_boc_deserialize(broadcast.data));
42
  TRY_RESULT(boc, vm::std_boc_serialize_multi({proof_root, data_root}, 2));
43
  td::BufferSlice data =
44
      create_serialize_tl_object<ton_api::tonNode_blockBroadcastCompressed_data>(std::move(sigs), std::move(boc));
45
  td::BufferSlice compressed = td::lz4_compress(data);
46
  VLOG(FULL_NODE_DEBUG) << "Compressing block broadcast: "
47
                        << broadcast.data.size() + broadcast.proof.size() + broadcast.signatures.size() * 96 << " -> "
48
                        << compressed.size();
49
  return create_serialize_tl_object<ton_api::tonNode_blockBroadcastCompressed>(
50
      create_tl_block_id(broadcast.block_id), broadcast.catchain_seqno, broadcast.validator_set_hash, 0,
51
      std::move(compressed));
52
}
53


54
static td::Result<BlockBroadcast> deserialize_block_broadcast(ton_api::tonNode_blockBroadcast& f) {
55
  std::vector<BlockSignature> signatures;
56
  for (auto& sig : f.signatures_) {
57
    signatures.emplace_back(BlockSignature{sig->who_, std::move(sig->signature_)});
58
  }
59
  return BlockBroadcast{create_block_id(f.id_),
60
                        std::move(signatures),
61
                        static_cast<UnixTime>(f.catchain_seqno_),
62
                        static_cast<td::uint32>(f.validator_set_hash_),
63
                        std::move(f.data_),
64
                        std::move(f.proof_)};
65
}
66


67
static td::Result<BlockBroadcast> deserialize_block_broadcast(ton_api::tonNode_blockBroadcastCompressed& f,
68
                                                              int max_decompressed_size) {
69
  TRY_RESULT(decompressed, td::lz4_decompress(f.compressed_, max_decompressed_size));
70
  TRY_RESULT(f2, fetch_tl_object<ton_api::tonNode_blockBroadcastCompressed_data>(decompressed, true));
71
  std::vector<BlockSignature> signatures;
72
  for (auto& sig : f2->signatures_) {
73
    signatures.emplace_back(BlockSignature{sig->who_, std::move(sig->signature_)});
74
  }
75
  TRY_RESULT(roots, vm::std_boc_deserialize_multi(f2->proof_data_, 2));
76
  if (roots.size() != 2) {
77
    return td::Status::Error("expected 2 roots in boc");
78
  }
79
  TRY_RESULT(proof, vm::std_boc_serialize(roots[0], 0));
80
  TRY_RESULT(data, vm::std_boc_serialize(roots[1], 31));
81
  VLOG(FULL_NODE_DEBUG) << "Decompressing block broadcast: " << f.compressed_.size() << " -> "
82
                        << data.size() + proof.size() + signatures.size() * 96;
83
  return BlockBroadcast{create_block_id(f.id_),
84
                        std::move(signatures),
85
                        static_cast<UnixTime>(f.catchain_seqno_),
86
                        static_cast<td::uint32>(f.validator_set_hash_),
87
                        std::move(data),
88
                        std::move(proof)};
89
}
90


91
td::Result<BlockBroadcast> deserialize_block_broadcast(ton_api::tonNode_Broadcast& obj,
92
                                                       int max_decompressed_data_size) {
93
  td::Result<BlockBroadcast> B;
94
  ton_api::downcast_call(obj,
95
                         td::overloaded([&](ton_api::tonNode_blockBroadcast& f) { B = deserialize_block_broadcast(f); },
96
                                        [&](ton_api::tonNode_blockBroadcastCompressed& f) {
97
                                          B = deserialize_block_broadcast(f, max_decompressed_data_size);
98
                                        },
99
                                        [&](auto&) { B = td::Status::Error("unknown broadcast type"); }));
100
  return B;
101
}
102


103
td::Result<td::BufferSlice> serialize_block_full(const BlockIdExt& id, td::Slice proof, td::Slice data,
104
                                                 bool is_proof_link, bool compression_enabled) {
105
  if (!compression_enabled) {
106
    return create_serialize_tl_object<ton_api::tonNode_dataFull>(create_tl_block_id(id), td::BufferSlice(proof),
107
                                                                 td::BufferSlice(data), is_proof_link);
108
  }
109
  TRY_RESULT(proof_root, vm::std_boc_deserialize(proof));
110
  TRY_RESULT(data_root, vm::std_boc_deserialize(data));
111
  TRY_RESULT(boc, vm::std_boc_serialize_multi({proof_root, data_root}, 2));
112
  td::BufferSlice compressed = td::lz4_compress(boc);
113
  VLOG(FULL_NODE_DEBUG) << "Compressing block full: " << data.size() + proof.size() << " -> " << compressed.size();
114
  return create_serialize_tl_object<ton_api::tonNode_dataFullCompressed>(create_tl_block_id(id), 0,
115
                                                                         std::move(compressed), is_proof_link);
116
}
117


118
static td::Status deserialize_block_full(ton_api::tonNode_dataFull& f, BlockIdExt& id, td::BufferSlice& proof,
119
                                         td::BufferSlice& data, bool& is_proof_link) {
120
  id = create_block_id(f.id_);
121
  proof = std::move(f.proof_);
122
  data = std::move(f.block_);
123
  is_proof_link = f.is_link_;
124
  return td::Status::OK();
125
}
126


127
static td::Status deserialize_block_full(ton_api::tonNode_dataFullCompressed& f, BlockIdExt& id, td::BufferSlice& proof,
128
                                         td::BufferSlice& data, bool& is_proof_link, int max_decompressed_size) {
129
  TRY_RESULT(decompressed, td::lz4_decompress(f.compressed_, max_decompressed_size));
130
  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, 2));
131
  if (roots.size() != 2) {
132
    return td::Status::Error("expected 2 roots in boc");
133
  }
134
  TRY_RESULT_ASSIGN(proof, vm::std_boc_serialize(roots[0], 0));
135
  TRY_RESULT_ASSIGN(data, vm::std_boc_serialize(roots[1], 31));
136
  VLOG(FULL_NODE_DEBUG) << "Decompressing block full: " << f.compressed_.size() << " -> " << data.size() + proof.size();
137
  id = create_block_id(f.id_);
138
  is_proof_link = f.is_link_;
139
  return td::Status::OK();
140
}
141


142
td::Status deserialize_block_full(ton_api::tonNode_DataFull& obj, BlockIdExt& id, td::BufferSlice& proof,
143
                                  td::BufferSlice& data, bool& is_proof_link, int max_decompressed_data_size) {
144
  td::Status S;
145
  ton_api::downcast_call(
146
      obj, td::overloaded(
147
               [&](ton_api::tonNode_dataFull& f) { S = deserialize_block_full(f, id, proof, data, is_proof_link); },
148
               [&](ton_api::tonNode_dataFullCompressed& f) {
149
                 S = deserialize_block_full(f, id, proof, data, is_proof_link, max_decompressed_data_size);
150
               },
151
               [&](auto&) { S = td::Status::Error("unknown data type"); }));
152
  return S;
153
}
154


155
td::Result<td::BufferSlice> serialize_block_candidate_broadcast(BlockIdExt block_id, CatchainSeqno cc_seqno,
156
                                                                td::uint32 validator_set_hash, td::Slice data,
157
                                                                bool compression_enabled) {
158
  if (!compression_enabled) {
159
    return create_serialize_tl_object<ton_api::tonNode_newBlockCandidateBroadcast>(
160
        create_tl_block_id(block_id), cc_seqno, validator_set_hash,
161
        create_tl_object<ton_api::tonNode_blockSignature>(Bits256::zero(), td::BufferSlice()), td::BufferSlice(data));
162
  }
163
  TRY_RESULT(root, vm::std_boc_deserialize(data));
164
  TRY_RESULT(data_new, vm::std_boc_serialize(root, 2));
165
  td::BufferSlice compressed = td::lz4_compress(data_new);
166
  VLOG(FULL_NODE_DEBUG) << "Compressing block candidate broadcast: " << data.size() << " -> " << compressed.size();
167
  return create_serialize_tl_object<ton_api::tonNode_newBlockCandidateBroadcastCompressed>(
168
      create_tl_block_id(block_id), cc_seqno, validator_set_hash,
169
      create_tl_object<ton_api::tonNode_blockSignature>(Bits256::zero(), td::BufferSlice()), 0, std::move(compressed));
170
}
171


172
static td::Status deserialize_block_candidate_broadcast(ton_api::tonNode_newBlockCandidateBroadcast& obj,
173
                                                        BlockIdExt& block_id, CatchainSeqno& cc_seqno,
174
                                                        td::uint32& validator_set_hash, td::BufferSlice& data) {
175
  block_id = create_block_id(obj.id_);
176
  cc_seqno = obj.catchain_seqno_;
177
  validator_set_hash = obj.validator_set_hash_;
178
  data = std::move(obj.data_);
179
  return td::Status::OK();
180
}
181


182
static td::Status deserialize_block_candidate_broadcast(ton_api::tonNode_newBlockCandidateBroadcastCompressed& obj,
183
                                                        BlockIdExt& block_id, CatchainSeqno& cc_seqno,
184
                                                        td::uint32& validator_set_hash, td::BufferSlice& data,
185
                                                        int max_decompressed_data_size) {
186
  block_id = create_block_id(obj.id_);
187
  cc_seqno = obj.catchain_seqno_;
188
  validator_set_hash = obj.validator_set_hash_;
189
  TRY_RESULT(decompressed, td::lz4_decompress(obj.compressed_, max_decompressed_data_size));
190
  TRY_RESULT(root, vm::std_boc_deserialize(decompressed));
191
  TRY_RESULT_ASSIGN(data, vm::std_boc_serialize(root, 31));
192
  VLOG(FULL_NODE_DEBUG) << "Decompressing block candidate broadcast: " << obj.compressed_.size() << " -> "
193
                        << data.size();
194
  return td::Status::OK();
195
}
196


197
td::Status deserialize_block_candidate_broadcast(ton_api::tonNode_Broadcast& obj, BlockIdExt& block_id,
198
                                                 CatchainSeqno& cc_seqno, td::uint32& validator_set_hash,
199
                                                 td::BufferSlice& data, int max_decompressed_data_size) {
200
  td::Status S;
201
  ton_api::downcast_call(obj, td::overloaded(
202
                                  [&](ton_api::tonNode_newBlockCandidateBroadcast& f) {
203
                                    S = deserialize_block_candidate_broadcast(f, block_id, cc_seqno, validator_set_hash,
204
                                                                              data);
205
                                  },
206
                                  [&](ton_api::tonNode_newBlockCandidateBroadcastCompressed& f) {
207
                                    S = deserialize_block_candidate_broadcast(f, block_id, cc_seqno, validator_set_hash,
208
                                                                              data, max_decompressed_data_size);
209
                                  },
210
                                  [&](auto&) { S = td::Status::Error("unknown data type"); }));
211
  return S;
212
}
213


214
}  // namespace ton::validator::fullnode
215

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.