diff --git a/dht-server/dht-server.cpp b/dht-server/dht-server.cpp
index 3bd65cc6..01ee105d 100644
--- a/dht-server/dht-server.cpp
+++ b/dht-server/dht-server.cpp
@@ -38,9 +38,6 @@
 #include "td/utils/TsFileLog.h"
 #include "td/utils/Random.h"
 
-#include "ton/ton-tl.hpp"
-#include "tl/tl_json.h"
-
 #include "memprof/memprof.h"
 
 #if TD_DARWIN || TD_LINUX
@@ -57,7 +54,7 @@ Config::Config() {
   out_port = 3278;
 }
 
-Config::Config(const ton::ton_api::engine_validator_configV2 &config) {
+Config::Config(const ton::ton_api::engine_validator_config &config) {
   out_port = static_cast<td::uint16>(config.out_port_);
   if (!out_port) {
     out_port = 3278;
@@ -124,7 +121,7 @@ Config::Config(const ton::ton_api::engine_validator_configV2 &config) {
   }
 }
 
-ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
+ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
   std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
   for (auto &x : addrs) {
     if (x.second.proxy) {
@@ -150,6 +147,7 @@ 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;
+  std::vector<ton::tl_object_ptr<ton::ton_api::engine_collator>> col_vec;
 
   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;
@@ -165,15 +163,16 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
     control_vec.push_back(ton::create_tl_object<ton::ton_api::engine_controlInterface>(x.second.key.tl(), x.first,
                                                                                        std::move(control_proc_vec)));
   }
+  std::vector<ton::tl_object_ptr<ton::ton_api::tonNode_shardId>> shard_vec;
 
   auto gc_vec = ton::create_tl_object<ton::ton_api::engine_gc>(std::vector<td::Bits256>{});
   for (auto &id : gc) {
     gc_vec->ids_.push_back(id.tl());
   }
   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),
+      out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), std::move(col_vec),
       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));
+      std::move(liteserver_vec), std::move(control_vec), std::move(shard_vec), std::move(gc_vec));
 }
 
 td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
@@ -600,14 +599,14 @@ void DhtServer::load_config(td::Promise<td::Unit> promise) {
   }
   auto conf_json = conf_json_R.move_as_ok();
 
-  ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
-  auto S = td::from_json(conf, std::move(conf_json));
+  ton::ton_api::engine_validator_config conf;
+  auto S = ton::ton_api::from_json(conf, conf_json.get_object());
   if (S.is_error()) {
     promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
     return;
   }
 
-  config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
+  config_ = Config{conf};
 
   td::MultiPromise mp;
   auto ig = mp.init_guard();
diff --git a/dht-server/dht-server.hpp b/dht-server/dht-server.hpp
index 724232fa..bf815202 100644
--- a/dht-server/dht-server.hpp
+++ b/dht-server/dht-server.hpp
@@ -91,10 +91,10 @@ struct Config {
   td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
   td::Result<bool> config_del_gc(ton::PublicKeyHash key);
 
-  ton::tl_object_ptr<ton::ton_api::engine_validator_Config> tl() const;
+  ton::tl_object_ptr<ton::ton_api::engine_validator_config> tl() const;
 
   Config();
-  Config(const ton::ton_api::engine_validator_configV2 &config);
+  Config(const ton::ton_api::engine_validator_config &config);
 };
 
 class DhtServer : public td::actor::Actor {
diff --git a/lite-client/lite-client.cpp b/lite-client/lite-client.cpp
index 970cdad9..7165ca53 100644
--- a/lite-client/lite-client.cpp
+++ b/lite-client/lite-client.cpp
@@ -124,7 +124,7 @@ void TestNode::run() {
   auto gc_j = td::json_decode(G.as_slice()).move_as_ok();
   ton::ton_api::liteclient_config_global gc;
   ton::ton_api::from_json(gc, gc_j.get_object()).ensure();
-  CHECK(gc.liteservers_.size() > 0);
+  CHECK(gc.liteservers_.size() + gc.liteservers_v2_.size() > 0);
 
   if (gc.validator_ && gc.validator_->zero_state_) {
     zstate_id_.workchain = gc.validator_->zero_state_->workchain_;
@@ -137,21 +137,19 @@ void TestNode::run() {
 
   for (auto& server : gc.liteservers_) {
     LiteServer s;
-    ton::ton_api::downcast_call(*server,
-                                td::overloaded(
-                                    [&](ton::ton_api::liteserver_desc& obj) {
-                                      s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure();
-                                      s.public_key = ton::PublicKey{obj.id_};
-                                    },
-                                    [&](ton::ton_api::liteserver_descV2& obj) {
-                                      s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure();
-                                      s.public_key = ton::PublicKey{obj.id_};
-                                      s.is_full = false;
-                                      for (const auto& shard : obj.shards_) {
-                                        s.shards.emplace_back(shard->workchain_, shard->shard_);
-                                        CHECK(s.shards.back().is_valid_ext());
-                                      }
-                                    }));
+    s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
+    s.public_key = ton::PublicKey{server->id_};
+    servers_.push_back(std::move(s));
+  }
+  for (auto& server : gc.liteservers_v2_) {
+    LiteServer s;
+    s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
+    s.public_key = ton::PublicKey{server->id_};
+    s.is_full = false;
+    for (const auto& shard : server->shards_) {
+      s.shards.emplace_back(shard->workchain_, shard->shard_);
+      CHECK(s.shards.back().is_valid_ext());
+    }
     servers_.push_back(std::move(s));
   }
 
diff --git a/tl/generate/scheme/ton_api.tl b/tl/generate/scheme/ton_api.tl
index ff03764a..67b123c8 100644
--- a/tl/generate/scheme/ton_api.tl
+++ b/tl/generate/scheme/ton_api.tl
@@ -578,8 +578,8 @@ validator.config.global zero_state:tonNode.blockIdExt init_block:tonNode.blockId
 config.global adnl:adnl.config.global dht:dht.config.global validator:validator.config.global = config.Global;
 
 liteserver.desc id:PublicKey ip:int port:int = liteserver.Desc;
-liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = liteserver.Desc;
-liteclient.config.global liteservers:(vector liteserver.Desc) validator:validator.config.global = liteclient.config.Global;
+liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = 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;
 engine.addr ip:int port:int categories:(vector int) priority_categories:(vector int) = engine.Addr;
@@ -598,14 +598,8 @@ engine.gc ids:(vector int256) = engine.Gc;
 engine.dht.config dht:(vector engine.dht) gc:engine.gc = engine.dht.Config;
 engine.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNodeMaster;
 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 fullnodeslaves:(vector engine.validator.fullNodeSlave)
-        fullnodemasters:(vector engine.validator.fullNodeMaster)
-        liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
-        gc:engine.gc = engine.validator.Config;
 
-engine.validator.configV2 out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl)
+engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl)
         dht:(vector engine.dht)
         validators:(vector engine.validator) collators:(vector engine.collator)
         fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)
diff --git a/tl/generate/scheme/ton_api.tlo b/tl/generate/scheme/ton_api.tlo
index 12399020..25b64d21 100644
Binary files a/tl/generate/scheme/ton_api.tlo and b/tl/generate/scheme/ton_api.tlo differ
diff --git a/ton/ton-tl.hpp b/ton/ton-tl.hpp
index 5df54ec6..1bc9a28c 100644
--- a/ton/ton-tl.hpp
+++ b/ton/ton-tl.hpp
@@ -62,23 +62,4 @@ inline tl_object_ptr<ton_api::tonNode_shardId> create_tl_shard_id(const ShardIdF
   return create_tl_object<ton_api::tonNode_shardId>(s.workchain, s.shard);
 }
 
-inline tl_object_ptr<ton_api::engine_validator_configV2> unpack_engine_validator_config(
-    tl_object_ptr<ton_api::engine_validator_Config> config) {
-  tl_object_ptr<ton_api::engine_validator_configV2> res;
-  ton_api::downcast_call(*config, td::overloaded(
-                                      [&](ton_api::engine_validator_config &c) {
-                                        res = create_tl_object<ton_api::engine_validator_configV2>(
-                                            c.out_port_, std::move(c.addrs_), std::move(c.adnl_), std::move(c.dht_),
-                                            std::move(c.validators_),
-                                            std::vector<tl_object_ptr<ton_api::engine_collator>>(), c.fullnode_,
-                                            std::move(c.fullnodeslaves_), std::move(c.fullnodemasters_),
-                                            std::move(c.liteservers_), std::move(c.control_),
-                                            std::vector<tl_object_ptr<ton_api::tonNode_shardId>>(), std::move(c.gc_));
-                                      },
-                                      [&](ton_api::engine_validator_configV2 &c) {
-                                        res = std::make_unique<ton_api::engine_validator_configV2>(std::move(c));
-                                      }));
-  return res;
-}
-
 }  // namespace ton
diff --git a/validator-engine/validator-engine.cpp b/validator-engine/validator-engine.cpp
index e56dfb7b..2aaff674 100644
--- a/validator-engine/validator-engine.cpp
+++ b/validator-engine/validator-engine.cpp
@@ -75,7 +75,7 @@ Config::Config() {
   full_node = ton::PublicKeyHash::zero();
 }
 
-Config::Config(const ton::ton_api::engine_validator_configV2 &config) {
+Config::Config(const ton::ton_api::engine_validator_config &config) {
   full_node = ton::PublicKeyHash::zero();
   out_port = static_cast<td::uint16>(config.out_port_);
   if (!out_port) {
@@ -177,7 +177,7 @@ Config::Config(const ton::ton_api::engine_validator_configV2 &config) {
   }
 }
 
-ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
+ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
   std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
   for (auto &x : addrs) {
     if (x.second.proxy) {
@@ -257,17 +257,10 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
     gc_vec->ids_.push_back(id.tl());
   }
 
-  if (col_vec.empty() && shards_vec.empty()) {
-    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),
-        full_node.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));
-  } else {
-    return ton::create_tl_object<ton::ton_api::engine_validator_configV2>(
-        out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), std::move(col_vec),
-        full_node.tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec), std::move(liteserver_vec),
-        std::move(control_vec), std::move(shards_vec), std::move(gc_vec));
-  }
+  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), std::move(col_vec),
+      full_node.tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec), std::move(liteserver_vec),
+      std::move(control_vec), std::move(shards_vec), std::move(gc_vec));
 }
 
 td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
@@ -1662,14 +1655,14 @@ void ValidatorEngine::load_config(td::Promise<td::Unit> promise) {
   }
   auto conf_json = conf_json_R.move_as_ok();
 
-  ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
-  auto S = td::from_json(conf, std::move(conf_json));
+  ton::ton_api::engine_validator_config conf;
+  auto S = ton::ton_api::from_json(conf, conf_json.get_object());
   if (S.is_error()) {
     promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
     return;
   }
 
-  config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
+  config_ = Config{conf};
 
   td::MultiPromise mp;
   auto ig = mp.init_guard();
diff --git a/validator-engine/validator-engine.hpp b/validator-engine/validator-engine.hpp
index 40a04c70..69ef5cb0 100644
--- a/validator-engine/validator-engine.hpp
+++ b/validator-engine/validator-engine.hpp
@@ -137,10 +137,10 @@ struct Config {
   td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
   td::Result<bool> config_del_gc(ton::PublicKeyHash key);
 
-  ton::tl_object_ptr<ton::ton_api::engine_validator_Config> tl() const;
+  ton::tl_object_ptr<ton::ton_api::engine_validator_config> tl() const;
 
   Config();
-  Config(const ton::ton_api::engine_validator_configV2 &config);
+  Config(const ton::ton_api::engine_validator_config &config);
 };
 
 class ValidatorEngine : public td::actor::Actor {
diff --git a/validator/full-node-shard.cpp b/validator/full-node-shard.cpp
index 7bf44f33..2101435f 100644
--- a/validator/full-node-shard.cpp
+++ b/validator/full-node-shard.cpp
@@ -663,11 +663,11 @@ void FullNodeShardImpl::process_broadcast(PublicKeyHash src, ton_api::tonNode_ne
 
 void FullNodeShardImpl::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
   BlockIdExt block_id = create_block_id(query.id_);
-  if (block_id.shard_full() != shard_) {
-    LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str()
-                           << " block=" << block_id.to_str();
-    return;
-  }
+  //if (block_id.shard_full() != shard_) {
+  //  LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str()
+  //                         << " block=" << block_id.to_str();
+  //  return;
+  //}
 
   std::vector<BlockSignature> signatures;
   for (auto &sig : query.signatures_) {