updated tonlib, new fullnode queries

CMakeLists.txt

@@ -71,7 +71,7 @@ endif()
 
 #BEGIN internal
 option(TON_ONLY_TONLIB "Use \"ON\" to build only tonlib." OFF)
-if (TON_ONLY_TONBLIB)
+if (TON_ONLY_TONLIB)
   set(NOT_TON_ONLY_TONLIB false)
 else()
   set(NOT_TON_ONLY_TONLIB true)

adnl/adnl-ext-client.cpp

@@ -176,6 +176,113 @@ td::Status AdnlOutboundConnection::process_packet(td::BufferSlice data) {
   return td::Status::OK();
 }
 
+void AdnlExtMultiClientImpl::start_up() {
+  for (auto &id : ids_) {
+    add_server(id.first, id.second, [](td::Result<td::Unit> R) {});
+  }
+  ids_.clear();
+}
+
+void AdnlExtMultiClientImpl::add_server(AdnlNodeIdFull dst, td::IPAddress dst_addr, td::Promise<td::Unit> promise) {
+  for (auto &c : clients_) {
+    if (c.second->addr == dst_addr) {
+      promise.set_error(td::Status::Error(ErrorCode::error, "duplicate ip"));
+      return;
+    }
+  }
+
+  auto g = ++generation_;
+  auto cli = std::make_unique<Client>(AdnlExtClient::create(dst, dst_addr, make_callback(g)), dst, dst_addr, g);
+  clients_[g] = std::move(cli);
+}
+
+void AdnlExtMultiClientImpl::del_server(td::IPAddress dst_addr, td::Promise<td::Unit> promise) {
+  for (auto &c : clients_) {
+    if (c.second->addr == dst_addr) {
+      if (c.second->ready) {
+        total_ready_--;
+        if (!total_ready_) {
+          callback_->on_stop_ready();
+        }
+      }
+      clients_.erase(c.first);
+      promise.set_value(td::Unit());
+      return;
+    }
+  }
+  promise.set_error(td::Status::Error(ErrorCode::error, "ip not found"));
+}
+
+void AdnlExtMultiClientImpl::send_query(std::string name, td::BufferSlice data, td::Timestamp timeout,
+                                        td::Promise<td::BufferSlice> promise) {
+  if (total_ready_ == 0) {
+    promise.set_error(td::Status::Error(ErrorCode::notready, "conn not ready"));
+    return;
+  }
+
+  std::vector<td::uint32> vec;
+  for (auto &c : clients_) {
+    if (c.second->ready) {
+      vec.push_back(c.first);
+    }
+  }
+  CHECK(vec.size() == total_ready_);
+
+  auto &c = clients_[vec[td::Random::fast(0, td::narrow_cast<td::uint32>(vec.size() - 1))]];
+
+  td::actor::send_closure(c->client, &AdnlExtClient::send_query, std::move(name), std::move(data), timeout,
+                          std::move(promise));
+}
+
+void AdnlExtMultiClientImpl::client_ready(td::uint32 idx, bool value) {
+  auto it = clients_.find(idx);
+  if (it == clients_.end()) {
+    return;
+  }
+  auto &c = it->second;
+  if (c->ready == value) {
+    return;
+  }
+  c->ready = value;
+  if (value) {
+    total_ready_++;
+    if (total_ready_ == 1) {
+      callback_->on_ready();
+    }
+  } else {
+    total_ready_--;
+    if (total_ready_ == 0) {
+      callback_->on_stop_ready();
+    }
+  }
+}
+
+std::unique_ptr<AdnlExtClient::Callback> AdnlExtMultiClientImpl::make_callback(td::uint32 g) {
+  class Cb : public Callback {
+   public:
+    Cb(td::actor::ActorId<AdnlExtMultiClientImpl> id, td::uint32 idx) : id_(id), idx_(idx) {
+    }
+
+    void on_ready() override {
+      td::actor::send_closure(id_, &AdnlExtMultiClientImpl::client_ready, idx_, true);
+    }
+
+    void on_stop_ready() override {
+      td::actor::send_closure(id_, &AdnlExtMultiClientImpl::client_ready, idx_, false);
+    }
+
+   private:
+    td::actor::ActorId<AdnlExtMultiClientImpl> id_;
+    td::uint32 idx_;
+  };
+  return std::make_unique<Cb>(actor_id(this), g);
+}
+
+td::actor::ActorOwn<AdnlExtMultiClient> AdnlExtMultiClient::create(
+    std::vector<std::pair<AdnlNodeIdFull, td::IPAddress>> ids, std::unique_ptr<AdnlExtClient::Callback> callback) {
+  return td::actor::create_actor<AdnlExtMultiClientImpl>("extmulticlient", std::move(ids), std::move(callback));
+}
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-ext-client.h

@@ -43,6 +43,14 @@ class AdnlExtClient : public td::actor::Actor {
                                                    std::unique_ptr<AdnlExtClient::Callback> callback);
 };
 
+class AdnlExtMultiClient : public AdnlExtClient {
+ public:
+  virtual void add_server(AdnlNodeIdFull dst, td::IPAddress dst_addr, td::Promise<td::Unit> promise) = 0;
+  virtual void del_server(td::IPAddress dst_addr, td::Promise<td::Unit> promise) = 0;
+  static td::actor::ActorOwn<AdnlExtMultiClient> create(std::vector<std::pair<AdnlNodeIdFull, td::IPAddress>> ids,
+                                                        std::unique_ptr<AdnlExtClient::Callback> callback);
+};
+
 }  // namespace adnl
 
 }  // namespace ton

adnl/adnl-ext-client.hpp

@@ -140,6 +140,52 @@ class AdnlExtClientImpl : public AdnlExtClient {
   void try_stop();
 };
 
+class AdnlExtMultiClientImpl : public AdnlExtMultiClient {
+ public:
+  AdnlExtMultiClientImpl(std::vector<std::pair<AdnlNodeIdFull, td::IPAddress>> ids,
+                         std::unique_ptr<AdnlExtClient::Callback> callback)
+      : ids_(std::move(ids)), callback_(std::move(callback)) {
+  }
+
+  void start_up() override;
+
+  void add_server(AdnlNodeIdFull dst, td::IPAddress dst_addr, td::Promise<td::Unit> promise) override;
+  void del_server(td::IPAddress dst_addr, td::Promise<td::Unit> promise) override;
+
+  void check_ready(td::Promise<td::Unit> promise) override {
+    if (total_ready_ > 0) {
+      promise.set_value(td::Unit());
+    } else {
+      promise.set_error(td::Status::Error(ErrorCode::notready, "conn not ready"));
+    }
+  }
+  void send_query(std::string name, td::BufferSlice data, td::Timestamp timeout,
+                  td::Promise<td::BufferSlice> promise) override;
+
+  void client_ready(td::uint32 idx, bool value);
+
+ private:
+  std::unique_ptr<Callback> make_callback(td::uint32 g);
+
+  struct Client {
+    Client(td::actor::ActorOwn<AdnlExtClient> client, AdnlNodeIdFull pubkey, td::IPAddress addr, td::uint32 generation)
+        : client(std::move(client)), pubkey(std::move(pubkey)), addr(addr), generation(generation), ready(false) {
+    }
+    td::actor::ActorOwn<AdnlExtClient> client;
+    AdnlNodeIdFull pubkey;
+    td::IPAddress addr;
+    td::uint32 generation;
+    bool ready = false;
+  };
+  td::uint32 total_ready_ = 0;
+
+  td::uint32 generation_ = 0;
+  std::map<td::uint32, std::unique_ptr<Client>> clients_;
+
+  std::vector<std::pair<AdnlNodeIdFull, td::IPAddress>> ids_;
+  std::unique_ptr<AdnlExtClient::Callback> callback_;
+};
+
 }  // namespace adnl
 
 }  // namespace ton

dht-server/dht-server.cpp

@@ -139,8 +139,8 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
 
   std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator>> val_vec;
 
-  ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeSlave> full_node_slave_ = nullptr;
-  std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_;
+  std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeSlave>> full_node_slaves_vec;
+  std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_vec;
 
   std::vector<ton::tl_object_ptr<ton::ton_api::engine_liteServer>> liteserver_vec;
 
@@ -160,7 +160,7 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
   }
   return ton::create_tl_object<ton::ton_api::engine_validator_config>(
       out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec),
-      ton::PublicKeyHash::zero().tl(), std::move(full_node_slave_), std::move(full_node_masters_),
+      ton::PublicKeyHash::zero().tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec),
       std::move(liteserver_vec), std::move(control_vec), std::move(gc_vec));
 }
 

tdutils/td/utils/Timer.cpp

@@ -25,15 +25,40 @@
 
 namespace td {
 
-Timer::Timer() : start_time_(Time::now()) {
+Timer::Timer(bool is_paused) : is_paused_(is_paused) {
+  if (is_paused_) {
+    start_time_ = 0;
+  } else {
+    start_time_ = Time::now();
+  }
+}
+
+void Timer::pause() {
+  if (is_paused_) {
+    return;
+  }
+  elapsed_ += Time::now() - start_time_;
+  is_paused_ = true;
+}
+
+void Timer::resume() {
+  if (!is_paused_) {
+    return;
+  }
+  start_time_ = Time::now();
+  is_paused_ = false;
 }
 
 double Timer::elapsed() const {
-  return Time::now() - start_time_;
+  double res = elapsed_;
+  if (!is_paused_) {
+    res += Time::now() - start_time_;
+  }
+  return res;
 }
 
 StringBuilder &operator<<(StringBuilder &string_builder, const Timer &timer) {
-  return string_builder << "in " << Time::now() - timer.start_time_;
+  return string_builder << format::as_time(timer.elapsed());
 }
 
 PerfWarningTimer::PerfWarningTimer(string name, double max_duration)

tdutils/td/utils/Timer.h

@@ -24,14 +24,22 @@ namespace td {
 
 class Timer {
  public:
-  Timer();
+  Timer() : Timer(false) {
+  }
+  explicit Timer(bool is_paused);
+  Timer(const Timer &other) = default;
+  Timer &operator=(const Timer &other) = default;
 
   double elapsed() const;
+  void pause();
+  void resume();
 
  private:
   friend StringBuilder &operator<<(StringBuilder &string_builder, const Timer &timer);
 
+  double elapsed_{0};
   double start_time_;
+  bool is_paused_{false};
 };
 
 class PerfWarningTimer {

tl/generate/scheme/ton_api.tl

@@ -322,6 +322,7 @@ tonNode.zeroStateIdExt workchain:int root_hash:int256 file_hash:int256 = tonNode
 
 tonNode.blockDescriptionEmpty = tonNode.BlockDescription;
 tonNode.blockDescription id:tonNode.blockIdExt = tonNode.BlockDescription;
+tonNode.blocksDescription ids:(vector tonNode.blockIdExt) incomplete:Bool = tonNode.BlocksDescription;
 tonNode.preparedProofEmpty = tonNode.PreparedProof;
 tonNode.preparedProof = tonNode.PreparedProof;
 tonNode.preparedProofLink = tonNode.PreparedProof;
@@ -352,20 +353,34 @@ tonNode.keyBlocks blocks:(vector tonNode.blockIdExt) incomplete:Bool error:Bool
 ton.blockId root_cell_hash:int256 file_hash:int256 = ton.BlockId;
 ton.blockIdApprove root_cell_hash:int256 file_hash:int256 = ton.BlockId;
 
+tonNode.dataList data:(vector bytes) = tonNode.DataList;
+
+tonNode.dataFull id:tonNode.blockIdExt proof:bytes block:bytes is_link:Bool = tonNode.DataFull;
+tonNode.dataFullEmpty = tonNode.DataFull;
+
 ---functions---
 
 tonNode.getNextBlockDescription prev_block:tonNode.blockIdExt = tonNode.BlockDescription;
+tonNode.getNextBlocksDescription prev_block:tonNode.blockIdExt limit:int = tonNode.BlocksDescription;
+tonNode.getPrevBlocksDescription next_block:tonNode.blockIdExt limit:int cutoff_seqno:int = tonNode.BlocksDescription;
 tonNode.prepareBlockProof block:tonNode.blockIdExt allow_partial:Bool = tonNode.PreparedProof;
+tonNode.prepareBlockProofs blocks:(vector tonNode.blockIdExt) allow_partial:Bool = tonNode.PreparedProof;
 tonNode.prepareBlock block:tonNode.blockIdExt = tonNode.Prepared;
+tonNode.prepareBlocks blocks:(vector tonNode.blockIdExt) = tonNode.Prepared;
 tonNode.preparePersistentState block:tonNode.blockIdExt masterchain_block:tonNode.blockIdExt = tonNode.PreparedState;
 tonNode.prepareZeroState block:tonNode.blockIdExt = tonNode.PreparedState;
 tonNode.getNextKeyBlockIds block:tonNode.blockIdExt max_size:int = tonNode.KeyBlocks;
+tonNode.downloadNextBlockFull prev_block:tonNode.blockIdExt = tonNode.DataFull;
+tonNode.downloadBlockFull block:tonNode.blockIdExt = tonNode.DataFull;
 tonNode.downloadBlock block:tonNode.blockIdExt = tonNode.Data;
+tonNode.downloadBlocks blocks:(vector tonNode.blockIdExt) = tonNode.DataList;
 tonNode.downloadPersistentState block:tonNode.blockIdExt masterchain_block:tonNode.blockIdExt = tonNode.Data;
 tonNode.downloadPersistentStateSlice block:tonNode.blockIdExt masterchain_block:tonNode.blockIdExt offset:long max_size:long = tonNode.Data;
 tonNode.downloadZeroState block:tonNode.blockIdExt = tonNode.Data;
 tonNode.downloadBlockProof block:tonNode.blockIdExt = tonNode.Data;
+tonNode.downloadBlockProofs blocks:(vector tonNode.blockIdExt) = tonNode.DataList;
 tonNode.downloadBlockProofLink block:tonNode.blockIdExt = tonNode.Data;
+tonNode.downloadBlockProofLinks blocks:(vector tonNode.blockIdExt) = tonNode.DataList;
 
 tonNode.slave.sendExtMessage message:tonNode.externalMessage = True;
 
@@ -490,7 +505,7 @@ engine.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNode
 engine.validator.fullNodeSlave ip:int port:int adnl:PublicKey = engine.validator.FullNodeSlave;
 engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl) 
         dht:(vector engine.dht)
-        validators:(vector engine.validator) fullnode:int256 fullnodeslave:engine.validator.fullNodeSlave
+        validators:(vector engine.validator) fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)
         fullnodemasters:(vector engine.validator.fullNodeMaster)
         liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
         gc:engine.gc = engine.validator.Config; 

tl/generate/scheme/tonlib_api.tl

@@ -32,7 +32,7 @@ internal.transactionId lt:int64 hash:bytes = internal.TransactionId;
 
 raw.initialAccountState code:bytes data:bytes = raw.InitialAccountState;
 raw.accountState balance:int64 code:bytes data:bytes last_transaction_id:internal.transactionId sync_utime:int53 = raw.AccountState;
-raw.message source:string destination:string value:int64 = raw.Message;
+raw.message source:string destination:string value:int64 message:bytes = raw.Message;
 raw.transaction utime:int53 data:bytes transaction_id:internal.transactionId fee:int64 in_msg:raw.message out_msgs:vector<raw.message> = raw.Transaction;
 raw.transactions transactions:vector<raw.Transaction> previous_transaction_id:internal.transactionId = raw.Transactions;
 
@@ -81,15 +81,15 @@ raw.getTransactions account_address:accountAddress from_transaction_id:internal.
 testWallet.init private_key:inputKey = Ok;
 testWallet.getAccountAddress initital_account_state:testWallet.initialAccountState = AccountAddress;
 testWallet.getAccountState account_address:accountAddress = testWallet.AccountState;
-testWallet.sendGrams private_key:inputKey destination:accountAddress seqno:int32 amount:int64 = Ok;
+testWallet.sendGrams private_key:inputKey destination:accountAddress seqno:int32 amount:int64 message:bytes = Ok;
 
 testGiver.getAccountState = testGiver.AccountState;
 testGiver.getAccountAddress = AccountAddress;
-testGiver.sendGrams destination:accountAddress seqno:int32 amount:int64 = Ok;
+testGiver.sendGrams destination:accountAddress seqno:int32 amount:int64 message:bytes = Ok;
 
 //generic.getAccountAddress initital_account_state:generic.InitialAccountState = AccountAddress;
 generic.getAccountState account_address:accountAddress = generic.AccountState;
-generic.sendGrams private_key:inputKey source:accountAddress destination:accountAddress amount:int64 = Ok;
+generic.sendGrams private_key:inputKey source:accountAddress destination:accountAddress amount:int64 message:bytes = Ok;
 
 onLiteServerQueryResult id:int64 bytes:bytes = Ok;
 onLiteServerQueryError id:int64 error:error = Ok;

tonlib/CMakeLists.txt

@@ -13,6 +13,7 @@ set(TONLIB_SOURCE
   tonlib/GenericAccount.cpp
   tonlib/KeyStorage.cpp
   tonlib/LastBlock.cpp
+  tonlib/LastBlockStorage.cpp
   tonlib/TestGiver.cpp
   tonlib/TestWallet.cpp
   tonlib/TonlibClient.cpp
@@ -26,6 +27,7 @@ set(TONLIB_SOURCE
   tonlib/GenericAccount.h
   tonlib/KeyStorage.h
   tonlib/LastBlock.h
+  tonlib/LastBlockStorage.h
   tonlib/TestGiver.h
   tonlib/TestWallet.h
   tonlib/TonlibCallback.h

tonlib/test/offline.cpp

@@ -127,8 +127,8 @@ TEST(Tonlib, TestGiver) {
 
   auto wallet_query = fift_output.source_lookup.read_file("wallet-query.boc").move_as_ok().data;
 
-  auto res = GenericAccount::create_ext_message(TestGiver::address(), {},
-                                                TestGiver::make_a_gift_message(0, 1000000000ll * 6666 / 1000, address));
+  auto res = GenericAccount::create_ext_message(
+      TestGiver::address(), {}, TestGiver::make_a_gift_message(0, 1000000000ll * 6666 / 1000, "GIFT", address));
   vm::CellSlice(vm::NoVm(), res).print_rec(std::cerr);
   CHECK(vm::std_boc_deserialize(wallet_query).move_as_ok()->get_hash() == res->get_hash());
 }