Allow hostnames instead of IPs for liteservers (#1771)

SpyCheese · web-flow · commit 8a49651b611c · 2025-08-07T12:42:03.000+03:00
diff --git a/adnl/adnl-ext-client.cpp b/adnl/adnl-ext-client.cpp
@@ -31,6 +31,14 @@ void AdnlExtClientImpl::alarm() {
     next_create_at_ = td::Timestamp::in(10.0);
     alarm_timestamp() = next_create_at_;
 
+    if (!dst_host_.empty()) {
+      auto S = dst_addr_.init_host_port(dst_host_);
+      if (S.is_error()) {
+        LOG(INFO) << "failed to connect to " << dst_host_ << ": " << S;
+        return;
+      }
+      LOG(DEBUG) << "resolved " << dst_host_ << " -> " << dst_addr_;
+    }
     auto fd = td::SocketFd::open(dst_addr_);
     if (fd.is_error()) {
       LOG(INFO) << "failed to connect to " << dst_addr_ << ": " << fd.move_as_error();
@@ -166,6 +174,12 @@ td::actor::ActorOwn<AdnlExtClient> AdnlExtClient::create(AdnlNodeIdFull dst, td:
   return td::actor::create_actor<AdnlExtClientImpl>("extclient", std::move(dst), dst_addr, std::move(callback));
 }
 
+td::actor::ActorOwn<AdnlExtClient> AdnlExtClient::create(AdnlNodeIdFull dst, std::string dst_host,
+                                                         std::unique_ptr<AdnlExtClient::Callback> callback) {
+  return td::actor::create_actor<AdnlExtClientImpl>("extclient", std::move(dst), std::move(dst_host),
+                                                    std::move(callback));
+}
+
 td::actor::ActorOwn<AdnlExtClient> AdnlExtClient::create(AdnlNodeIdFull dst, PrivateKey local_id,
                                                          td::IPAddress dst_addr,
                                                          std::unique_ptr<AdnlExtClient::Callback> callback) {
diff --git a/adnl/adnl-ext-client.h b/adnl/adnl-ext-client.h
@@ -39,6 +39,8 @@ class AdnlExtClient : public td::actor::Actor {
                           td::Promise<td::BufferSlice> promise) = 0;
   static td::actor::ActorOwn<AdnlExtClient> create(AdnlNodeIdFull dst, td::IPAddress dst_addr,
                                                    std::unique_ptr<AdnlExtClient::Callback> callback);
+  static td::actor::ActorOwn<AdnlExtClient> create(AdnlNodeIdFull dst, std::string dst_host,
+                                                   std::unique_ptr<AdnlExtClient::Callback> callback);
   static td::actor::ActorOwn<AdnlExtClient> create(AdnlNodeIdFull dst, PrivateKey local_id, td::IPAddress dst_addr,
                                                    std::unique_ptr<AdnlExtClient::Callback> callback);
 };
diff --git a/adnl/adnl-ext-client.hpp b/adnl/adnl-ext-client.hpp
@@ -71,6 +71,9 @@ class AdnlExtClientImpl : public AdnlExtClient {
   AdnlExtClientImpl(AdnlNodeIdFull dst_id, td::IPAddress dst_addr, std::unique_ptr<Callback> callback)
       : dst_(std::move(dst_id)), dst_addr_(dst_addr), callback_(std::move(callback)) {
   }
+  AdnlExtClientImpl(AdnlNodeIdFull dst_id, std::string dst_host, std::unique_ptr<Callback> callback)
+      : dst_(std::move(dst_id)), dst_host_(std::move(dst_host)), callback_(std::move(callback)) {
+  }
   AdnlExtClientImpl(AdnlNodeIdFull dst_id, PrivateKey local_id, td::IPAddress dst_addr,
                     std::unique_ptr<Callback> callback)
       : dst_(std::move(dst_id)), local_id_(local_id), dst_addr_(dst_addr), callback_(std::move(callback)) {
@@ -133,6 +136,7 @@ class AdnlExtClientImpl : public AdnlExtClient {
   AdnlNodeIdFull dst_;
   PrivateKey local_id_;
   td::IPAddress dst_addr_;
+  std::string dst_host_;
 
   std::unique_ptr<Callback> callback_;
 
diff --git a/blockchain-explorer/blockchain-explorer-query.cpp b/blockchain-explorer/blockchain-explorer-query.cpp
@@ -1429,10 +1429,10 @@ void HttpQueryStatus::finish_query() {
         A << "<td>" << static_cast<td::int32>(x->ts_.at_unix()) << "</td>";
       }
       A << "</tr>\n";
-      for (td::uint32 i = 0; i < results_.ips.size(); i++) {
+      for (td::uint32 i = 0; i < results_.addrs.size(); i++) {
         A << "<tr>";
-        if (results_.ips[i].is_valid()) {
-          A << "<td>" << results_.ips[i].get_ip_str() << ":" << results_.ips[i].get_port() << "</td>";
+        if (!results_.addrs[i].empty()) {
+          A << "<td>" << results_.addrs[i] << "</td>";
         } else {
           A << "<td>hidden</td>";
         }
diff --git a/blockchain-explorer/blockchain-explorer.cpp b/blockchain-explorer/blockchain-explorer.cpp
@@ -187,7 +187,7 @@ class CoreActor : public CoreActorInterface {
   std::mutex queue_mutex_;
   std::mutex res_mutex_;
   std::map<td::int32, std::shared_ptr<RemoteNodeStatus>> results_;
-  std::vector<td::IPAddress> addrs_;
+  std::vector<std::string> addrs_;
   static CoreActor* instance_;
   td::actor::ActorId<CoreActor> self_id_;
 
@@ -220,7 +220,7 @@ class CoreActor : public CoreActorInterface {
   }
   void get_results(td::uint32 max, td::Promise<RemoteNodeStatusList> promise) override {
     RemoteNodeStatusList r;
-    r.ips = hide_ips_ ? std::vector<td::IPAddress>{addrs_.size()} : addrs_;
+    r.addrs = hide_ips_ ? std::vector<std::string>{addrs_.size()} : addrs_;
     auto it = results_.rbegin();
     while (it != results_.rend() && r.results.size() < max) {
       r.results.push_back(it->second);
@@ -445,14 +445,14 @@ class CoreActor : public CoreActorInterface {
       r_servers.ensure();
       servers = r_servers.move_as_ok();
       for (const auto& serv : servers) {
-        addrs_.push_back(serv.addr);
+        addrs_.push_back(serv.hostname);
       }
     } else {
       if (!remote_addr_.is_valid()) {
         LOG(FATAL) << "remote addr not set";
       }
-      addrs_.push_back(remote_addr_);
       servers.push_back(liteclient::LiteServerConfig{ton::adnl::AdnlNodeIdFull{remote_public_key_}, remote_addr_});
+      addrs_.push_back(servers.back().hostname);
     }
     n_servers_ = servers.size();
     client_ = liteclient::ExtClient::create(std::move(servers), make_callback(), true);
diff --git a/blockchain-explorer/blockchain-explorer.hpp b/blockchain-explorer/blockchain-explorer.hpp
@@ -59,7 +59,7 @@ class CoreActorInterface : public td::actor::Actor {
   };
 
   struct RemoteNodeStatusList {
-    std::vector<td::IPAddress> ips;
+    std::vector<std::string> addrs;
     std::vector<std::shared_ptr<RemoteNodeStatus>> results;
   };
   virtual ~CoreActorInterface() = default;
diff --git a/lite-client/ext-client.cpp b/lite-client/ext-client.cpp
@@ -104,7 +104,7 @@ class ExtClientImpl : public ExtClient {
       promise.set_result(std::move(R));
     };
     LOG(DEBUG) << "Sending query " << query_info.to_str() << " to server #" << server.idx << " ("
-               << server.config.addr.get_ip_str() << ":" << server.config.addr.get_port() << ")";
+               << server.config.hostname << ")";
     send_closure(server.client, &ton::adnl::AdnlExtClient::send_query, std::move(name), std::move(data), timeout,
                  std::move(P));
   }
@@ -173,9 +173,9 @@ class ExtClientImpl : public ExtClient {
       td::actor::ActorId<ExtClientImpl> parent_;
       size_t idx_;
     };
-    LOG(INFO) << "Connecting to liteserver #" << server.idx << " (" << server.config.addr.get_ip_str() << ":"
-              << server.config.addr.get_port() << ") for query " << (query_info ? query_info->to_str() : "[none]");
-    server.client = ton::adnl::AdnlExtClient::create(server.config.adnl_id, server.config.addr,
+    LOG(INFO) << "Connecting to liteserver #" << server.idx << " (" << server.config.hostname << ") for query "
+              << (query_info ? query_info->to_str() : "[none]");
+    server.client = ton::adnl::AdnlExtClient::create(server.config.adnl_id, server.config.hostname,
                                                      std::make_unique<Callback>(actor_id(this), server_idx));
   }
 
@@ -204,8 +204,7 @@ class ExtClientImpl : public ExtClient {
         continue;
       }
       if (server.timeout.is_in_past()) {
-        LOG(INFO) << "Closing connection to liteserver #" << server.idx << " (" << server.config.addr.get_ip_str()
-                  << ":" << server.config.addr.get_port() << ")";
+        LOG(INFO) << "Closing connection to liteserver #" << server.idx << " (" << server.config.hostname << ")";
         server.client.reset();
         server.alive = false;
         server.ignore_until = {};
diff --git a/lite-client/lite-client.cpp b/lite-client/lite-client.cpp
@@ -108,7 +108,7 @@ void TestNode::run() {
     if (single_liteserver_idx_ != -1) {  // Use single liteserver from config
       CHECK(single_liteserver_idx_ >= 0 && (size_t)single_liteserver_idx_ < servers.size());
       td::TerminalIO::out() << "using liteserver #" << single_liteserver_idx_ << " with addr "
-                            << servers[single_liteserver_idx_].addr << "\n";
+                            << servers[single_liteserver_idx_].hostname << "\n";
       servers = {servers[single_liteserver_idx_]};
     }
   }
diff --git a/lite-client/query-utils.cpp b/lite-client/query-utils.cpp
@@ -318,16 +318,25 @@ bool LiteServerConfig::Slice::accepts_query(const QueryInfo& query_info) const {
 td::Result<std::vector<LiteServerConfig>> LiteServerConfig::parse_global_config(
     const ton_api::liteclient_config_global& config) {
   std::vector<LiteServerConfig> servers;
+  auto get_hostname = [](const auto& f) -> std::string {
+    if (f->hostname_.empty()) {
+      return PSTRING() << td::IPAddress::ipv4_to_str(f->ip_) << ":" << f->port_;
+    }
+    if (f->port_ == 0) {
+      return f->hostname_;
+    }
+    return PSTRING() << f->hostname_ << ":" << f->port_;
+  };
   for (const auto& f : config.liteservers_) {
     LiteServerConfig server;
-    TRY_STATUS(server.addr.init_host_port(td::IPAddress::ipv4_to_str(f->ip_), f->port_));
+    server.hostname = get_hostname(f);
     server.adnl_id = adnl::AdnlNodeIdFull{PublicKey{f->id_}};
     server.is_full = true;
     servers.push_back(std::move(server));
   }
   for (const auto& f : config.liteservers_v2_) {
     LiteServerConfig server;
-    TRY_STATUS(server.addr.init_host_port(td::IPAddress::ipv4_to_str(f->ip_), f->port_));
+    server.hostname = get_hostname(f);
     server.adnl_id = adnl::AdnlNodeIdFull{PublicKey{f->id_}};
     server.is_full = false;
     for (const auto& slice_obj : f->slices_) {
diff --git a/lite-client/query-utils.hpp b/lite-client/query-utils.hpp
@@ -73,11 +73,14 @@ struct LiteServerConfig {
 
  public:
   ton::adnl::AdnlNodeIdFull adnl_id;
-  td::IPAddress addr;
+  std::string hostname;
 
   LiteServerConfig() = default;
-  LiteServerConfig(ton::adnl::AdnlNodeIdFull adnl_id, td::IPAddress addr)
-      : is_full(true), adnl_id(adnl_id), addr(addr) {
+  LiteServerConfig(ton::adnl::AdnlNodeIdFull adnl_id, std::string hostname)
+      : is_full(true), adnl_id(adnl_id), hostname(std::move(hostname)) {
+  }
+  LiteServerConfig(ton::adnl::AdnlNodeIdFull adnl_id, td::IPAddress ip)
+      : is_full(true), adnl_id(adnl_id), hostname(PSTRING() << ip.get_ip_str() << ":" << ip.get_port()) {
   }
 
   bool accepts_query(const QueryInfo& query_info) const;
diff --git a/tl/generate/scheme/ton_api.tl b/tl/generate/scheme/ton_api.tl
@@ -657,8 +657,8 @@ liteserver.descV2.sliceSimple shards:(vector tonNode.shardId) = liteserver.descV
 liteserver.descV2.shardInfo shard_id:tonNode.shardId seqno:int utime:int lt:long = liteserver.descV2.ShardInfo;
 liteserver.descV2.sliceTimed shards_from:(vector liteserver.descV2.shardInfo) shards_to:(vector liteserver.descV2.shardInfo) = liteserver.descV2.Slice;
 
-liteserver.desc id:PublicKey ip:int port:int = liteserver.Desc;
-liteserver.descV2 id:PublicKey ip:int port:int slices:(vector liteserver.descV2.Slice) = liteserver.DescV2;
+liteserver.desc id:PublicKey ip:int port:int hostname:string = liteserver.Desc;
+liteserver.descV2 id:PublicKey ip:int port:int hostname:string slices:(vector liteserver.descV2.Slice) = liteserver.DescV2;
 liteclient.config.global liteservers:(vector liteserver.desc) liteservers_v2:(vector liteserver.descV2) validator:validator.config.global = liteclient.config.Global;
 
 engine.adnl id:int256 category:int = engine.Adnl;
diff --git a/tl/generate/scheme/ton_api.tlo b/tl/generate/scheme/ton_api.tlo
diff --git a/utils/proxy-liteserver.cpp b/utils/proxy-liteserver.cpp
@@ -184,7 +184,7 @@ class ProxyLiteserver : public td::actor::Actor {
 
     for (size_t i = 0; i < servers_.size(); ++i) {
       Server& server = servers_[i];
-      server.client = adnl::AdnlExtClient::create(server.config.adnl_id, server.config.addr,
+      server.client = adnl::AdnlExtClient::create(server.config.adnl_id, server.config.hostname,
                                                   std::make_unique<Callback>(actor_id(this), i));
       server.alive = false;
     }
@@ -197,7 +197,7 @@ class ProxyLiteserver : public td::actor::Actor {
     }
     server.alive = ready;
     LOG(WARNING) << (ready ? "Connected to" : "Disconnected from") << " server #" << idx << " ("
-                 << server.config.addr.get_ip_str() << ":" << server.config.addr.get_port() << ")";
+                 << server.config.hostname << ")";
   }
 
   void create_ext_server() {
@@ -295,8 +295,7 @@ class ProxyLiteserver : public td::actor::Actor {
     Server& server = servers_[server_idx];
     LOG(INFO) << "Sending query " << query_info.to_str()
               << (wait_mc_seqno_obj ? PSTRING() << " (wait seqno " << wait_mc_seqno_obj->seqno_ << ")" : "")
-              << ", size=" << data.size() << ", to server #" << server_idx << " (" << server.config.addr.get_ip_str()
-              << ":" << server.config.addr.get_port() << ")";
+              << ", size=" << data.size() << ", to server #" << server_idx << " (" << server.config.hostname << ")";
 
     BlockSeqno wait_mc_seqno = wait_mc_seqno_obj ? wait_mc_seqno_obj->seqno_ : 0;
     wait_mc_seqno = std::max(wait_mc_seqno, last_known_masterchain_seqno_);

Original file line number	Diff line number	Diff line change
`@@ -1429,10 +1429,10 @@ void HttpQueryStatus::finish_query() {`
`1429`	`1429`	`A << "<td>" << static_cast<td::int32>(x->ts_.at_unix()) << "</td>";`
`1430`	`1430`	`}`
`1431`	`1431`	`A << "</tr>\n";`
`1432`		`- for (td::uint32 i = 0; i < results_.ips.size(); i++) {`
	`1432`	`+ for (td::uint32 i = 0; i < results_.addrs.size(); i++) {`
`1433`	`1433`	`A << "<tr>";`
`1434`		`- if (results_.ips[i].is_valid()) {`
`1435`		`- A << "<td>" << results_.ips[i].get_ip_str() << ":" << results_.ips[i].get_port() << "</td>";`
	`1434`	`+ if (!results_.addrs[i].empty()) {`
	`1435`	`+ A << "<td>" << results_.addrs[i] << "</td>";`
`1436`	`1436`	`} else {`
`1437`	`1437`	`A << "<td>hidden</td>";`
`1438`	`1438`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ void TestNode::run() {`
`108`	`108`	`if (single_liteserver_idx_ != -1) { // Use single liteserver from config`
`109`	`109`	`CHECK(single_liteserver_idx_ >= 0 && (size_t)single_liteserver_idx_ < servers.size());`
`110`	`110`	`td::TerminalIO::out() << "using liteserver #" << single_liteserver_idx_ << " with addr "`
`111`		`- << servers[single_liteserver_idx_].addr << "\n";`
	`111`	`+ << servers[single_liteserver_idx_].hostname << "\n";`
`112`	`112`	`servers = {servers[single_liteserver_idx_]};`
`113`	`113`	`}`
`114`	`114`	`}`