updated block header

1. Updated block header, proofs now contain more data
   Notice, that old proofs may become invalid in the future
2. Fixed message routing
3. Fixed block creator id in block header
4. Support for full proofs in tonlib
5. Support for partial state download
6. Some other bugfixes

validator/db/filedb.cpp

@@ -138,7 +138,35 @@ void FileDb::load_file(RefId ref_id, td::Promise<td::BufferSlice> promise) {
         }
       });
 
-  td::actor::create_actor<db::ReadFile>("readfile", get_file_name(ref_id, false), std::move(P)).release();
+  td::actor::create_actor<db::ReadFile>("readfile", get_file_name(ref_id, false), 0, -1, std::move(P)).release();
+}
+
+void FileDb::load_file_slice(RefId ref_id, td::int64 offset, td::int64 max_size, td::Promise<td::BufferSlice> promise) {
+  auto ref_id_hash = get_ref_id_hash(ref_id);
+  auto R = get_block(ref_id_hash);
+  if (R.is_error()) {
+    promise.set_error(R.move_as_error());
+    return;
+  }
+
+  auto v = R.move_as_ok();
+
+  auto P = td::PromiseCreator::lambda(
+      [promise = std::move(promise), file_hash = v.file_hash](td::Result<td::BufferSlice> R) mutable {
+        if (R.is_error()) {
+          promise.set_error(R.move_as_error());
+        } else {
+          auto data = R.move_as_ok();
+          if (file_hash != sha256_bits256(data.as_slice())) {
+            promise.set_error(td::Status::Error(ErrorCode::protoviolation, PSTRING() << "db error: bad file hash"));
+          } else {
+            promise.set_value(std::move(data));
+          }
+        }
+      });
+
+  td::actor::create_actor<db::ReadFile>("readfile", get_file_name(ref_id, false), offset, max_size, std::move(P))
+      .release();
 }
 
 void FileDb::check_file(RefId ref_id, td::Promise<bool> promise) {

validator/db/filedb.hpp

@@ -144,6 +144,7 @@ class FileDb : public td::actor::Actor {
   void store_file(RefId ref_id, td::BufferSlice data, td::Promise<FileHash> promise);
   void store_file_continue(RefId ref_id, FileHash file_hash, std::string path, td::Promise<FileHash> promise);
   void load_file(RefId ref_id, td::Promise<td::BufferSlice> promise);
+  void load_file_slice(RefId ref_id, td::int64 offset, td::int64 max_size, td::Promise<td::BufferSlice> promise);
   void check_file(RefId ref_id, td::Promise<bool> promise);
 
   void start_up() override;

validator/db/files-async.hpp

@@ -82,7 +82,7 @@ class WriteFile : public td::actor::Actor {
 class ReadFile : public td::actor::Actor {
  public:
   void start_up() override {
-    auto S = td::read_file(file_name_);
+    auto S = td::read_file(file_name_, max_length_, offset_);
     if (S.is_ok()) {
       promise_.set_result(S.move_as_ok());
     } else {
@@ -92,12 +92,14 @@ class ReadFile : public td::actor::Actor {
     }
     stop();
   }
-  ReadFile(std::string file_name, td::Promise<td::BufferSlice> promise)
-      : file_name_(file_name), promise_(std::move(promise)) {
+  ReadFile(std::string file_name, td::int64 offset, td::int64 max_length, td::Promise<td::BufferSlice> promise)
+      : file_name_(file_name), offset_(offset), max_length_(max_length), promise_(std::move(promise)) {
   }
 
  private:
   std::string file_name_;
+  td::int64 offset_;
+  td::int64 max_length_;
   td::Promise<td::BufferSlice> promise_;
 };
 

validator/db/rootdb.cpp

@@ -299,6 +299,13 @@ void RootDb::get_persistent_state_file(BlockIdExt block_id, BlockIdExt mastercha
                           FileDb::RefId{fileref::PersistentState{block_id, masterchain_block_id}}, std::move(promise));
 }
 
+void RootDb::get_persistent_state_file_slice(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::int64 offset,
+                                             td::int64 max_size, td::Promise<td::BufferSlice> promise) {
+  td::actor::send_closure(archive_db_, &FileDb::load_file_slice,
+                          FileDb::RefId{fileref::PersistentState{block_id, masterchain_block_id}}, offset, max_size,
+                          std::move(promise));
+}
+
 void RootDb::check_persistent_state_file_exists(BlockIdExt block_id, BlockIdExt masterchain_block_id,
                                                 td::Promise<bool> promise) {
   td::actor::send_closure(archive_db_, &FileDb::check_file,

validator/db/rootdb.hpp

@@ -73,6 +73,8 @@ class RootDb : public Db {
                                    td::Promise<td::Unit> promise) override;
   void get_persistent_state_file(BlockIdExt block_id, BlockIdExt masterchain_block_id,
                                  td::Promise<td::BufferSlice> promise) override;
+  void get_persistent_state_file_slice(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::int64 offset,
+                                       td::int64 max_length, td::Promise<td::BufferSlice> promise) override;
   void check_persistent_state_file_exists(BlockIdExt block_id, BlockIdExt masterchain_block_id,
                                           td::Promise<bool> promise) override;
   void store_zero_state_file(BlockIdExt block_id, td::BufferSlice state, td::Promise<td::Unit> promise) override;

validator/db/staticfilesdb.cpp

@@ -25,7 +25,7 @@ namespace validator {
 
 void StaticFilesDb::load_file(FileHash file_hash, td::Promise<td::BufferSlice> promise) {
   auto path = path_ + "/" + file_hash.to_hex();
-  td::actor::create_actor<db::ReadFile>("read file", path, std::move(promise)).release();
+  td::actor::create_actor<db::ReadFile>("read file", path, 0, -1, std::move(promise)).release();
 }
 
 }  // namespace validator