Implement tonlib::EngineConsoleClient

Author: DanShaders

tonlib/tonlib/EngineConsoleClient.cpp

@@ -1,3 +1,6 @@
+#include "adnl/adnl-ext-client.h"
+#include "auto/tl/ton_api.hpp"
+
 #include "EngineConsoleClient.h"
 
 namespace tonlib {
@@ -11,13 +14,68 @@ bool is_engine_console_query(ton::tl_object_ptr<ton::ton_api::Function> const& f
   }
 }
 
-EngineConsoleClient::EngineConsoleClient(td::IPAddress address, ton::PublicKey public_key,
-                                         ton::PrivateKey private_key) {
+class EngineConsoleClientCallback : public ton::adnl::AdnlExtClient::Callback {
+ public:
+  EngineConsoleClientCallback(td::actor::ActorId<EngineConsoleClient> id) : id_(std::move(id)) {
+  }
+
+  void on_ready() override {
+    td::actor::send_closure(id_, &EngineConsoleClient::on_ready);
+  }
+
+  void on_stop_ready() override {
+    td::actor::send_closure(id_, &EngineConsoleClient::on_stop_ready);
+  }
+
+ private:
+  td::actor::ActorId<EngineConsoleClient> id_;
+};
+
+EngineConsoleClient::EngineConsoleClient(td::IPAddress address, ton::PublicKey public_key, ton::PrivateKey private_key)
+    : address_(address), public_key_(std::move(public_key)), private_key_(std::move(private_key)) {
+}
+
+void EngineConsoleClient::on_ready() {
+  ready_ = true;
+  for (auto& promise : pending_ready_promises_) {
+    promise.set_value(td::Unit());
+  }
+  pending_ready_promises_.clear();
+}
+
+void EngineConsoleClient::on_stop_ready() {
+  for (auto& promise : pending_ready_promises_) {
+    promise.set_error(td::Status::Error("Connection closed"));
+  }
+  pending_ready_promises_.clear();
+  ready_ = false;
+  client_ = {};
 }
 
 td::actor::Task<ton::tl_object_ptr<ton::ton_api::Object>> EngineConsoleClient::query(
     ton::tl_object_ptr<ton::ton_api::Function> object) {
-  co_return td::Status::Error("Not implemented");
+  if (!ready_) {
+    if (client_.empty()) {
+      client_ = ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull{public_key_}, private_key_, address_,
+                                                 std::make_unique<EngineConsoleClientCallback>(actor_id(this)));
+    }
+
+    auto [ready_awaiter, ready_promise] = td::actor::StartedTask<td::Unit>::make_bridge();
+    pending_ready_promises_.push_back(std::move(ready_promise));
+    co_await std::move(ready_awaiter);
+  }
+
+  auto query_bytes = ton::serialize_tl_object(object, true);
+  auto wrapped_query = ton::serialize_tl_object(
+      ton::create_tl_object<ton::ton_api::engine_validator_controlQuery>(std::move(query_bytes)), true);
+
+  auto [response_awaiter, response_promise] = td::actor::StartedTask<td::BufferSlice>::make_bridge();
+  td::actor::send_closure(client_, &ton::adnl::AdnlExtClient::send_query, "query", std::move(wrapped_query),
+                          td::Timestamp::in(10.0), std::move(response_promise));
+  auto response = co_await std::move(response_awaiter);
+
+  auto result_obj = co_await ton::fetch_tl_object<ton::ton_api::Object>(response, true);
+  co_return std::move(result_obj);
 }
 
 }  // namespace tonlib

tonlib/tonlib/EngineConsoleClient.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "adnl/adnl-ext-client.h"
 #include "keys/keys.hpp"
 #include "td/actor/actor.h"
 #include "td/actor/coro_task.h"
@@ -13,7 +14,18 @@ class EngineConsoleClient : public td::actor::Actor {
  public:
   EngineConsoleClient(td::IPAddress address, ton::PublicKey public_key, ton::PrivateKey private_key);
 
+  void on_ready();
+  void on_stop_ready();
+
   td::actor::Task<ton::tl_object_ptr<ton::ton_api::Object>> query(ton::tl_object_ptr<ton::ton_api::Function> function);
+
+ private:
+  td::IPAddress address_;
+  ton::PublicKey public_key_;
+  ton::PrivateKey private_key_;
+  td::actor::ActorOwn<ton::adnl::AdnlExtClient> client_;
+  bool ready_ = false;
+  std::vector<td::Promise<td::Unit>> pending_ready_promises_;
 };
 
 }  // namespace tonlib