Add admin actions on tonpy

tl/generate/scheme/lite_api.tl

@@ -24,7 +24,6 @@ adnl.message.query query_id:int256 query:bytes = adnl.Message;
 adnl.message.answer query_id:int256 answer:bytes = adnl.Message;
 
 liteServer.error code:int message:string = liteServer.Error;
-liteServer.success code:int = liteServer.Success;
 
 liteServer.accountId workchain:int id:int256 = liteServer.AccountId;
 liteServer.libraryEntry hash:int256 data:bytes = liteServer.LibraryEntry;
@@ -59,6 +58,9 @@ liteServer.shardBlockLink id:tonNode.blockIdExt proof:bytes = liteServer.ShardBl
 liteServer.shardBlockProof masterchain_id:tonNode.blockIdExt links:(vector liteServer.shardBlockLink) = liteServer.ShardBlockProof;
 
 liteServer.debug.verbosity value:int = liteServer.debug.Verbosity;
+liteServer.newUser pubkey:int256 short:int256 = liteServer.NewUser;
+liteServer.statItem shortid:int256 method:int start_at:int64 end_at:int64 success:Bool = liteServer.StatItem;
+liteServer.stats data:(vector liteServer.StatItem) = liteServer.Stats;
 
 ---functions---
 
@@ -88,9 +90,10 @@ liteServer.getLibraries library_list:(vector int256) = liteServer.LibraryResult;
 liteServer.getShardBlockProof id:tonNode.blockIdExt = liteServer.ShardBlockProof;
 
 // admin query
-liteServer.addUser pubkey:int256 valid_until:int64 ratelimit:int  = liteServer.Success;
+liteServer.addUser key:int256 valid_until:int64 ratelimit:int = liteServer.NewUser;
+liteServer.getStatData = liteServer.Stats;
 
-liteServer.queryPrefix = Object;
+liteServer.queryPrefix = Object; 
 liteServer.query data:bytes = Object;
 liteServer.adminQuery data:bytes = Object;
 liteServer.waitMasterchainSeqno seqno:int timeout_ms:int = Object; // query prefix

tl/generate/scheme/ton_api.tl

@@ -12,6 +12,7 @@ boolFalse = Bool;
 
 vector {t:Type} # [ t ] = Vector t;
 
+int64 2*[ int ] = Int64;
 int128 4*[ int ] = Int128;
 int256 8*[ int ] = Int256;
 
@@ -595,6 +596,10 @@ engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector eng
         liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
         gc:engine.gc = engine.validator.Config;
 
+engine.liteserver.config ip:int out_port:int adnl:(vector engine.adnl)
+        liteservers:(vector engine.liteServer) dht:(vector engine.dht)
+        fullnodeslaves:(vector engine.validator.fullNodeSlave) = engine.liteserver.Config;
+
 ---functions---
 ---types---
 
@@ -849,6 +854,7 @@ storage.daemon.providerInfo address:string balance:string config:storage.daemon.
     contracts_count:int contracts_total_size:long
     contracts:(vector storage.daemon.contractInfo) = storage.daemon.ProviderInfo;
 storage.daemon.providerAddress address:string = storage.daemon.ProviderAddress;
+storage.liteserver.user valid_until:int64 ratelimit:int = storage.liteserver.User;
 
 ---functions---
 storage.daemon.setVerbosity verbosity:int = storage.daemon.Success;

tvm-python/PyLiteClient.cpp

@@ -167,9 +167,15 @@ void LiteClientActorEngine::get_Block(ton::BlockIdExt blkid) {
   qprocess(std::move(q));
 }
 
-void LiteClientActorEngine::admin_AddUser(td::Bits256 pubkey, td::int64 valid_until, td::int32 ratelimit) {
+void LiteClientActorEngine::admin_AddUser(td::Bits256 privkey, td::int64 valid_until, td::int32 ratelimit) {
   auto q = ton::serialize_tl_object(
-      ton::create_tl_object<ton::lite_api::liteServer_addUser>(std::move(pubkey), valid_until, ratelimit), true);
+      ton::create_tl_object<ton::lite_api::liteServer_addUser>(std::move(privkey), valid_until, ratelimit), true);
+
+  admin_qprocess(std::move(q));
+}
+
+void LiteClientActorEngine::admin_GetStatData() {
+  auto q = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getStatData>(), true);
 
   admin_qprocess(std::move(q));
 }
@@ -510,25 +516,60 @@ TestNode::BlockHdrInfo PyLiteClient::get_BlockHeader(ton::BlockIdExt req_blkid,
   }
 }
 
-int PyLiteClient::admin_AddUser(std::string pubkey, td::int64 valid_until, td::int32 ratelimit) {
-  td::RefInt256 pubkey_int = td::string_to_int256(pubkey);
-  td::Bits256 pubkey_bits;
-  if (!pubkey_int->export_bytes(pubkey_bits.data(), 32, false)) {
+std::tuple<PubKeyHex, ShortKeyHex> PyLiteClient::admin_AddUser(std::string privkey, td::int64 valid_until,
+                                                               td::int32 ratelimit) {
+  td::RefInt256 pubkey_int = td::string_to_int256(privkey);
+  td::Bits256 privkey_bits;
+  if (!pubkey_int->export_bytes(privkey_bits.data(), 32, false)) {
     throw std::logic_error("Invalid pubkey");
   }
 
   scheduler_.run_in_context_external(
-      [&] { send_closure(engine, &LiteClientActorEngine::admin_AddUser, pubkey_bits, valid_until, ratelimit); });
+      [&] { send_closure(engine, &LiteClientActorEngine::admin_AddUser, privkey_bits, valid_until, ratelimit); });
 
   auto response = wait_response();
   if (response->success) {
     SuccessBufferSlice* data = dynamic_cast<SuccessBufferSlice*>(response.get());
-    return 0;
+    auto R = ton::fetch_tl_object<ton::lite_api::liteServer_newUser>(std::move(data->obj->clone()), true);
+    if (R.is_error()) {
+      throw_lite_error(data->obj->clone());
+    }
+    auto x = R.move_as_ok();
+
+    return std::make_tuple(x->pubkey_.to_hex(), x->short_.to_hex());
   } else {
     throw std::logic_error(response->error_message);
   }
 }
 
+std::vector<std::tuple<ShortKeyHex, int, td::int64, td::int64, bool>> PyLiteClient::admin_getStatData() {
+  scheduler_.run_in_context_external([&] { send_closure(engine, &LiteClientActorEngine::admin_GetStatData); });
+
+  auto response = wait_response();
+  if (response->success) {
+    SuccessBufferSlice* data = dynamic_cast<SuccessBufferSlice*>(response.get());
+    auto R = ton::fetch_tl_object<ton::lite_api::liteServer_stats>(std::move(data->obj->clone()), true);
+    if (R.is_error()) {
+      throw_lite_error(data->obj->clone());
+    }
+    auto x = R.move_as_ok();
+
+    std::vector<std::tuple<ShortKeyHex, int, td::int64, td::int64, bool>> tmp;
+    tmp.reserve(x->data_.size());
+
+    while (!x->data_.empty()) {
+      auto e = std::move(x->data_.back());
+      x->data_.pop_back();
+
+      tmp.emplace_back(e->shortid_.to_hex(), e->method_, e->start_at_, e->end_at_, e->success_);
+    }
+
+    return tmp;
+  } else {
+    throw std::logic_error(response->error_message);
+  }
+};
+
 PyCell PyLiteClient::get_Block(ton::BlockIdExt req_blkid) {
   scheduler_.run_in_context_external([&] { send_closure(engine, &LiteClientActorEngine::get_Block, req_blkid); });
 

tvm-python/PyLiteClient.h

@@ -27,6 +27,9 @@ std::string ipv4_int_to_str(int ipv4);
 
 // Response objects
 
+using PubKeyHex = std::string;
+using ShortKeyHex = std::string;
+
 class ResponseObj {
  public:
   ResponseObj(bool success_, std::string error_message_ = "")
@@ -111,6 +114,7 @@ class LiteClientActorEngine : public td::actor::Actor {
                                     std::optional<unsigned long long> lt = std::optional<unsigned long long>());
 
   void admin_AddUser(td::Bits256 pubkey, td::int64 valid_until, td::int32 ratelimit);
+  void admin_GetStatData();
 
   void run();
 
@@ -200,7 +204,8 @@ class PyLiteClient {
       ton::BlockIdExt blkid, int mode, int count, std::optional<td::string> account = std::optional<std::string>(),
       std::optional<unsigned long long> lt = std::optional<unsigned long long>());
   std::vector<ton::BlockId> get_AllShardsInfo(ton::BlockIdExt req_blkid);
-  int admin_AddUser(std::string pubkey, td::int64 valid_until, td::int32 ratelimit);
+  std::tuple<PubKeyHex, ShortKeyHex> admin_AddUser(std::string pubkey, td::int64 valid_until, td::int32 ratelimit);
+  std::vector<std::tuple<ShortKeyHex, int, td::int64, td::int64, bool>> admin_getStatData();
 
  private:
   std::shared_ptr<OutputQueue> response_obj_;

tvm-python/python_ton.cpp

@@ -470,6 +470,7 @@ PYBIND11_MODULE(python_ton, m) {
       .def("get_Block", &pylite::PyLiteClient::get_Block, py::arg("block_id"))
       .def("admin_AddUser", &pylite::PyLiteClient::admin_AddUser, py::arg("pubkey"), py::arg("validuntil"),
            py::arg("ratelimit"))
+      .def("admin_getStatData", &pylite::PyLiteClient::admin_getStatData)
       .def("get_Libraries", &pylite::PyLiteClient::get_Libraries, py::arg("libs"))
       .def("get_AllShardsInfo", &pylite::PyLiteClient::get_AllShardsInfo, py::arg("blkid"))
       .def("get_listBlockTransactionsExt", &pylite::PyLiteClient::get_listBlockTransactionsExt, py::arg("blkid"),