LS getDispatchQueueInfo and getDispatchQueueMessages methods (#1161)

* liteServer.getDispatchQueueInfo query

* Fix getting min/max lt

* LS getDispatchQueueMessages method

lite-client/lite-client.cpp

@@ -974,6 +974,11 @@ bool TestNode::show_help(std::string command) {
  "into files <filename-pfx><complaint-hash>.boc\n"
  "complaintprice <expires-in> <complaint-boc>\tComputes the price (in nanograms) for creating a complaint\n"
  "msgqueuesizes\tShows current sizes of outbound message queues in all shards\n"
+ "dispatchqueueinfo <block-id>\tShows list of account dispatch queue of a block\n"
+ "dispatchqueuemessages <block-id> <addr> [<after-lt>]\tShows deferred messages from account <addr>, lt > "
+ "<after_lt>\n"
+ "dispatchqueuemessagesall <block-id> [<after-addr> [<after-lt>]]\tShows messages from dispatch queue of a "
+ "block, starting after <after_addr>, <after-lt>\n"
  "known\tShows the list of all known block ids\n"
  "knowncells\tShows the list of hashes of all known (cached) cells\n"
  "dumpcell <hex-hash-pfx>\nDumps a cached cell by a prefix of its hash\n"
@@ -988,9 +993,9 @@ bool TestNode::show_help(std::string command) {
 bool TestNode::do_parse_line() {
  ton::WorkchainId workchain = ton::masterchainId; // change to basechain later
  int addr_ext = 0;
- ton::StdSmcAddress addr{};
+ ton::StdSmcAddress addr = ton::StdSmcAddress::zero();
  ton::BlockIdExt blkid{};
- ton::LogicalTime lt{};
+ ton::LogicalTime lt = 0;
  ton::Bits256 hash{};
  ton::ShardIdFull shard{};
  ton::BlockSeqno seqno{};
@@ -1118,6 +1123,16 @@ bool TestNode::do_parse_line() {
  set_error(get_complaint_price(expire_in, filename));
  } else if (word == "msgqueuesizes") {
  return get_msg_queue_sizes();
+ } else if (word == "dispatchqueueinfo") {
+ return parse_block_id_ext(blkid) && seekeoln() && get_dispatch_queue_info(blkid);
+ } else if (word == "dispatchqueuemessages" || word == "dispatchqueuemessagesall") {
+ bool one_account = word == "dispatchqueuemessages";
+ if (!parse_block_id_ext(blkid)) {
+ return false;
+ }
+ workchain = blkid.id.workchain;
+ return ((!one_account && seekeoln()) || parse_account_addr(workchain, addr)) && (seekeoln() || parse_lt(lt)) &&
+ seekeoln() && get_dispatch_queue_messages(blkid, workchain, addr, lt, one_account);
  } else if (word == "known") {
  return eoln() && show_new_blkids(true);
  } else if (word == "knowncells") {
@@ -1645,6 +1660,81 @@ void TestNode::got_msg_queue_sizes(ton::tl_object_ptr<ton::lite_api::liteServer_
  td::TerminalIO::out() << "External message queue size limit: " << f->ext_msg_queue_size_limit_ << std::endl;
 }
 
+bool TestNode::get_dispatch_queue_info(ton::BlockIdExt block_id) {
+ td::TerminalIO::out() << "Dispatch queue in block: " << block_id.id.to_str() << std::endl;
+ return get_dispatch_queue_info_cont(block_id, true, td::Bits256::zero());
+}
+
+bool TestNode::get_dispatch_queue_info_cont(ton::BlockIdExt block_id, bool first, td::Bits256 after_addr) {
+ auto q = ton::create_serialize_tl_object<ton::lite_api::liteServer_getDispatchQueueInfo>(
+ first ? 0 : 2, ton::create_tl_lite_block_id(block_id), after_addr, 32, false);
+ return envelope_send_query(std::move(q), [=, Self = actor_id(this)](td::Result<td::BufferSlice> res) -> void {
+ if (res.is_error()) {
+ LOG(ERROR) << "liteServer.getDispatchQueueInfo error: " << res.move_as_error();
+ return;
+ }
+ auto F = ton::fetch_tl_object<ton::lite_api::liteServer_dispatchQueueInfo>(res.move_as_ok(), true);
+ if (F.is_error()) {
+ LOG(ERROR) << "cannot parse answer to liteServer.getDispatchQueueInfo";
+ return;
+ }
+ td::actor::send_closure_later(Self, &TestNode::got_dispatch_queue_info, block_id, F.move_as_ok());
+ });
+}
+
+void TestNode::got_dispatch_queue_info(ton::BlockIdExt block_id,
+ ton::tl_object_ptr<ton::lite_api::liteServer_dispatchQueueInfo> info) {
+ for (auto& acc : info->account_dispatch_queues_) {
+ td::TerminalIO::out() << block_id.id.workchain << ":" << acc->addr_.to_hex() << " : size=" << acc->size_
+ << " lt=" << acc->min_lt_ << ".." << acc->max_lt_ << std::endl;
+ }
+ if (info->complete_) {
+ td::TerminalIO::out() << "Done" << std::endl;
+ return;
+ }
+ get_dispatch_queue_info_cont(block_id, false, info->account_dispatch_queues_.back()->addr_);
+}
+
+bool TestNode::get_dispatch_queue_messages(ton::BlockIdExt block_id, ton::WorkchainId wc, ton::StdSmcAddress addr,
+ ton::LogicalTime lt, bool one_account) {
+ if (wc != block_id.id.workchain) {
+ return set_error("workchain mismatch");
+ }
+ auto q = ton::create_serialize_tl_object<ton::lite_api::liteServer_getDispatchQueueMessages>(
+ one_account ? 2 : 0, ton::create_tl_lite_block_id(block_id), addr, lt, 64, false, one_account, false);
+ return envelope_send_query(std::move(q), [=, Self = actor_id(this)](td::Result<td::BufferSlice> res) -> void {
+ if (res.is_error()) {
+ LOG(ERROR) << "liteServer.getDispatchQueueMessages error: " << res.move_as_error();
+ return;
+ }
+ auto F = ton::fetch_tl_object<ton::lite_api::liteServer_dispatchQueueMessages>(res.move_as_ok(), true);
+ if (F.is_error()) {
+ LOG(ERROR) << "cannot parse answer to liteServer.getDispatchQueueMessages";
+ return;
+ }
+ td::actor::send_closure_later(Self, &TestNode::got_dispatch_queue_messages, F.move_as_ok());
+ });
+}
+
+void TestNode::got_dispatch_queue_messages(ton::tl_object_ptr<ton::lite_api::liteServer_dispatchQueueMessages> msgs) {
+ td::TerminalIO::out() << "Dispatch queue messages (" << msgs->messages_.size() << "):\n";
+ int count = 0;
+ for (auto& m : msgs->messages_) {
+ auto& meta = m->metadata_;
+ td::TerminalIO::out() << "Msg #" << ++count << ": " << msgs->id_->workchain_ << ":" << m->addr_.to_hex() << " "
+ << m->lt_ << " : "
+ << (meta->initiator_->workchain_ == ton::workchainInvalid
+ ? "[ no metadata ]"
+ : block::MsgMetadata{(td::uint32)meta->depth_, meta->initiator_->workchain_,
+ meta->initiator_->id_, (ton::LogicalTime)meta->initiator_lt_}
+ .to_str())
+ << "\n";
+ }
+ if (!msgs->complete_) {
+ td::TerminalIO::out() << "(incomplete list)\n";
+ }
+}
+
 bool TestNode::dns_resolve_start(ton::WorkchainId workchain, ton::StdSmcAddress addr, ton::BlockIdExt blkid,
  std::string domain, td::Bits256 cat, int mode) {
  if (domain.size() >= 2 && domain[0] == '"' && domain.back() == '"') {
@@ -4322,7 +4412,7 @@ int main(int argc, char* argv[]) {
  });
  p.add_option('V', "version", "shows lite-client build information", [&]() {
  std::cout << "lite-client build information: [ Commit: " << GitMetadata::CommitSHA1() << ", Date: " << GitMetadata::CommitDate() << "]\n";
- 
+
  std::exit(0);
  });
  p.add_option('i', "idx", "set liteserver idx", [&](td::Slice arg) {

lite-client/lite-client.h

@@ -307,6 +307,13 @@ class TestNode : public td::actor::Actor {
  unsigned refs, td::Bits256 chash, std::string filename);
  bool get_msg_queue_sizes();
  void got_msg_queue_sizes(ton::tl_object_ptr<ton::lite_api::liteServer_outMsgQueueSizes> f);
+ bool get_dispatch_queue_info(ton::BlockIdExt block_id);
+ bool get_dispatch_queue_info_cont(ton::BlockIdExt block_id, bool first, td::Bits256 after_addr);
+ void got_dispatch_queue_info(ton::BlockIdExt block_id,
+ ton::tl_object_ptr<ton::lite_api::liteServer_dispatchQueueInfo> info);
+ bool get_dispatch_queue_messages(ton::BlockIdExt block_id, ton::WorkchainId wc, ton::StdSmcAddress addr,
+ ton::LogicalTime lt, bool one_account);
+ void got_dispatch_queue_messages(ton::tl_object_ptr<ton::lite_api::liteServer_dispatchQueueMessages> msgs);
  bool cache_cell(Ref<vm::Cell> cell);
  bool list_cached_cells() const;
  bool dump_cached_cell(td::Slice hash_pfx, td::Slice type_name = {});

tl-utils/lite-utils.cpp

@@ -160,6 +160,8 @@ std::string lite_query_name_by_id(int id) {
  {lite_api::liteServer_getShardBlockProof::ID, "getShardBlockProof"},
  {lite_api::liteServer_getOutMsgQueueSizes::ID, "getOutMsgQueueSizes"},
  {lite_api::liteServer_getBlockOutMsgQueueSize::ID, "getBlockOutMsgQueueSize"},
+ {lite_api::liteServer_getDispatchQueueInfo::ID, "getDispatchQueueInfo"},
+ {lite_api::liteServer_getDispatchQueueMessages::ID, "getDispatchQueueMessages"},
  {lite_api::liteServer_nonfinal_getCandidate::ID, "nonfinal.getCandidate"},
  {lite_api::liteServer_nonfinal_getValidatorGroups::ID, "nonfinal.getValidatorGroups"}};
  auto it = names.find(id);

tl/generate/scheme/lite_api.tl

@@ -61,6 +61,11 @@ liteServer.lookupBlockResult id:tonNode.blockIdExt mode:# mc_block_id:tonNode.bl
 liteServer.outMsgQueueSize id:tonNode.blockIdExt size:int = liteServer.OutMsgQueueSize;
 liteServer.outMsgQueueSizes shards:(vector liteServer.outMsgQueueSize) ext_msg_queue_size_limit:int = liteServer.OutMsgQueueSizes;
 liteServer.blockOutMsgQueueSize mode:# id:tonNode.blockIdExt size:long proof:mode.0?bytes = liteServer.BlockOutMsgQueueSize;
+liteServer.accountDispatchQueueInfo addr:int256 size:long min_lt:long max_lt:long = liteServer.AccountDispatchQueueInfo;
+liteServer.dispatchQueueInfo mode:# id:tonNode.blockIdExt account_dispatch_queues:(vector liteServer.accountDispatchQueueInfo) complete:Bool proof:mode.0?bytes = liteServer.DispatchQueueInfo;
+liteServer.dispatchQueueMessage addr:int256 lt:long hash:int256 metadata:liteServer.transactionMetadata = liteServer.DispatchQueueMessage;
+liteServer.dispatchQueueMessages mode:# id:tonNode.blockIdExt messages:(vector liteServer.dispatchQueueMessage) complete:Bool
+ proof:mode.0?bytes messages_boc:mode.2?bytes = liteServer.DispatchQueueMessages;
 
 liteServer.debug.verbosity value:int = liteServer.debug.Verbosity;
 
@@ -100,6 +105,9 @@ liteServer.getLibrariesWithProof id:tonNode.blockIdExt mode:# library_list:(vect
 liteServer.getShardBlockProof id:tonNode.blockIdExt = liteServer.ShardBlockProof;
 liteServer.getOutMsgQueueSizes mode:# wc:mode.0?int shard:mode.0?long = liteServer.OutMsgQueueSizes;
 liteServer.getBlockOutMsgQueueSize mode:# id:tonNode.blockIdExt want_proof:mode.0?true = liteServer.BlockOutMsgQueueSize;
+liteServer.getDispatchQueueInfo mode:# id:tonNode.blockIdExt after_addr:mode.1?int256 max_accounts:int want_proof:mode.0?true = liteServer.DispatchQueueInfo;
+liteServer.getDispatchQueueMessages mode:# id:tonNode.blockIdExt addr:int256 after_lt:long max_messages:int
+ want_proof:mode.0?true one_account:mode.1?true messages_boc:mode.2?true = liteServer.DispatchQueueMessages;
 
 liteServer.nonfinal.getValidatorGroups mode:# wc:mode.0?int shard:mode.0?long = liteServer.nonfinal.ValidatorGroups;
 liteServer.nonfinal.getCandidate id:liteServer.nonfinal.candidateId = liteServer.nonfinal.Candidate;