Merge pull request #1828 from ton-blockchain/testnet

Merge develope branch

Author: EmelyanenkoK

.github/workflows/create-tolk-release.yml

@@ -9,6 +9,9 @@ on:
 
 permissions: write-all
 
+env:
+  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
 jobs:
   create-release:
     runs-on: ubuntu-22.04
@@ -152,3 +155,11 @@ jobs:
           asset_name: ton-wasm.zip
           tag: ${{ inputs.tag }}
 
+      - name: Upload stdlib
+        run: |
+          mkdir smartcont_lib
+          cd smartcont_lib
+          cp -r ../artifacts/ton-x86_64-linux/{smartcont,lib} .          
+          zip -r smartcont_lib.zip .
+          gh release upload ${{ inputs.tag }} smartcont_lib.zip
+

Changelog.md

@@ -1,3 +1,15 @@
+## 2025.10 Update
+
+1. [TVM version v12](./doc/GlobalVersions.md): full bounces, new `BTOS` and `HASHBU` instuctions, limit on contract size in masterchain.
+2. Optimistic collation/validation: allow nodes to generate and check block candidates before previous block is fully signed (not fully activated yet).
+3. Introduced custom block compression algorithm.
+4. Overlay improvements: improved overlay discovery on shard configuration update, private externals in custom overlays.
+5. Various improvements: session stats, telemetry in fast-sync overlay, earlier block broadcasts, limiting ttl for values in DHT, fixing search by utime in native blockexplorer, faster downloading candidates in validator session, parallelization of storing to cell_db, avoiding touching packfiles on startup.
+
+Besides the work of the core team, this update is based on the efforts of the Tonstudio team: @hacker-volodya @Shvandre; and @mkiesel (avoiding touching packfiles on startup).
+
+
+
 ## 2025.07 Accelerator Update
 
 Separation of validation and collation processes that allows to host them on independent machines and achieve full horizontal scaling. [More details in documentation](https://docs.ton.org/v3/documentation/infra/nodes/validation/collators)

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) {

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);
 };

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_;
 

blockchain-explorer/blockchain-explorer-query.cpp

@@ -525,8 +525,8 @@ HttpQueryBlockSearch::HttpQueryBlockSearch(std::map<std::string, std::string> op
   }
   if (opts.count("utime") == 1) {
     try {
-      seqno_ = static_cast<td::uint32>(std::stoull(opts["utime"]));
-      mode_ = 1;
+      utime_ = static_cast<td::uint32>(std::stoull(opts["utime"]));
+      mode_ = 4;
     } catch (...) {
       error_ = td::Status::Error("cannot parse utime");
       return;
@@ -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>";
         }

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);

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;

common/global-version.h

@@ -19,6 +19,6 @@
 namespace ton {
 
 // See doc/GlobalVersions.md
-constexpr int SUPPORTED_VERSION = 11;
+constexpr int SUPPORTED_VERSION = 12;
 
 }

create-hardfork/create-hardfork.cpp

@@ -280,9 +280,6 @@ class HardforkCreator : public td::actor::Actor {
 
       void new_key_block(ton::validator::BlockHandle handle) override {
       }
-      void send_validator_telemetry(ton::PublicKeyHash key,
-                                    ton::tl_object_ptr<ton::ton_api::validator_telemetry> telemetry) override {
-      }
     };
 
     td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::install_callback,