Node patch

catchain/catchain-receiver.cpp

@@ -526,10 +526,12 @@ void CatChainReceiverImpl::start_up() {
   for (td::uint32 i = 0; i < get_sources_cnt(); i++) {
     root_keys.emplace(get_source(i)->get_hash(), OVERLAY_MAX_ALLOWED_PACKET_SIZE);
   }
-  td::actor::send_closure(overlay_manager_, &overlay::Overlays::create_private_overlay,
+  overlay::OverlayOptions overlay_options;
+  overlay_options.broadcast_speed_multiplier_ = opts_.broadcast_speed_multiplier;
+  td::actor::send_closure(overlay_manager_, &overlay::Overlays::create_private_overlay_ex,
                           get_source(local_idx_)->get_adnl_id(), overlay_full_id_.clone(), std::move(ids),
                           make_callback(), overlay::OverlayPrivacyRules{0, 0, std::move(root_keys)},
-                          R"({ "type": "catchain" })");
+                          R"({ "type": "catchain" })", std::move(overlay_options));
 
   CHECK(root_block_);
 

crypto/block/block.cpp

@@ -360,7 +360,6 @@ MsgProcessedUptoCollection::MsgProcessedUptoCollection(ton::ShardIdFull _owner,
     z.shard = key.get_uint(64);
     z.mc_seqno = (unsigned)((key + 64).get_uint(32));
     z.last_inmsg_lt = value.write().fetch_ulong(64);
-    // std::cerr << "ProcessedUpto shard " << std::hex << z.shard << std::dec << std::endl;
     return value.write().fetch_bits_to(z.last_inmsg_hash) && z.shard && ton::shard_contains(owner.shard, z.shard);
   });
 }
@@ -862,8 +861,10 @@ td::Status ShardState::unpack_out_msg_queue_info(Ref<vm::Cell> out_msg_queue_inf
   out_msg_queue_ =
       std::make_unique<vm::AugmentedDictionary>(std::move(qinfo.out_queue), 352, block::tlb::aug_OutMsgQueue);
   if (verbosity >= 3 * 1) {
-    LOG(DEBUG) << "unpacking ProcessedUpto of our previous block " << id_.to_str();
-    block::gen::t_ProcessedInfo.print(std::cerr, qinfo.proc_info);
+    FLOG(DEBUG) {
+      sb << "unpacking ProcessedUpto of our previous block " << id_.to_str();
+      block::gen::t_ProcessedInfo.print(sb, qinfo.proc_info);
+    };
   }
   if (!block::gen::t_ProcessedInfo.validate_csr(1024, qinfo.proc_info)) {
     return td::Status::Error(

crypto/block/mc-config.cpp

@@ -163,8 +163,11 @@ td::Status ConfigInfo::unpack() {
   }
   gen::McStateExtra::Record extra_info;
   if (!tlb::unpack_cell(state_extra_root_, extra_info)) {
-    vm::load_cell_slice(state_extra_root_).print_rec(std::cerr);
-    block::gen::t_McStateExtra.print_ref(std::cerr, state_extra_root_);
+    FLOG(WARNING) {
+      sb << "state extra information is invalid: ";
+      vm::load_cell_slice(state_extra_root_).print_rec(sb);
+      block::gen::t_McStateExtra.print_ref(sb, state_extra_root_);
+    };
     return td::Status::Error("state extra information is invalid");
   }
   gen::ValidatorInfo::Record validator_info;
@@ -1067,7 +1070,6 @@ Ref<McShardHash> ShardConfig::get_shard_hash(ton::ShardIdFull id, bool exact) co
   ton::ShardIdFull true_id;
   vm::CellSlice cs;
   if (get_shard_hash_raw(cs, id, true_id, exact)) {
-    // block::gen::t_ShardDescr.print(std::cerr, vm::CellSlice{cs});
     return McShardHash::unpack(cs, true_id);
   } else {
     return {};
@@ -1637,8 +1639,10 @@ bool ShardConfig::set_shard_info(ton::ShardIdFull shard, Ref<vm::Cell> value) {
   if (!gen::t_BinTree_ShardDescr.validate_ref(1024, value)) {
     LOG(ERROR) << "attempting to store an invalid (BinTree ShardDescr) at shard configuration position "
                << shard.to_str();
-    gen::t_BinTree_ShardDescr.print_ref(std::cerr, value);
-    vm::load_cell_slice(value).print_rec(std::cerr);
+    FLOG(WARNING) {
+      gen::t_BinTree_ShardDescr.print_ref(sb, value);
+      vm::load_cell_slice(value).print_rec(sb);
+    };
     return false;
   }
   auto root = shard_hashes_dict_->lookup_ref(td::BitArray<32>{shard.workchain});

crypto/block/output-queue-merger.cpp

@@ -138,7 +138,6 @@ bool OutputQueueMerger::add_root(int src, Ref<vm::Cell> outmsg_root) {
   if (outmsg_root.is_null()) {
     return true;
   }
-  //block::gen::HashmapAug{352, block::gen::t_EnqueuedMsg, block::gen::t_uint64}.print_ref(std::cerr, outmsg_root);
   auto kv = std::make_unique<MsgKeyValue>(src, std::move(outmsg_root));
   if (kv->replace_by_prefix(common_pfx.cbits(), common_pfx_len)) {
     heap.push_back(std::move(kv));

crypto/block/transaction.cpp

@@ -446,8 +446,10 @@ bool Account::unpack(Ref<vm::CellSlice> shard_account, ton::UnixTime now, bool s
     return false;
   }
   if (verbosity > 2) {
-    shard_account->print_rec(std::cerr, 2);
-    block::gen::t_ShardAccount.print(std::cerr, *shard_account);
+    FLOG(INFO) {
+      shard_account->print_rec(sb, 2);
+      block::gen::t_ShardAccount.print(sb, shard_account);
+    };
   }
   block::gen::ShardAccount::Record acc_info;
   if (!(block::tlb::t_ShardAccount.validate_csr(shard_account) && tlb::unpack_exact(shard_account.write(), acc_info))) {
@@ -737,9 +739,11 @@ bool Transaction::unpack_input_msg(bool ihr_delivered, const ActionPhaseConfig*
     return false;
   }
   if (verbosity > 2) {
-    fprintf(stderr, "unpacking inbound message for a new transaction: ");
-    block::gen::t_Message_Any.print_ref(std::cerr, in_msg);
-    load_cell_slice(in_msg).print_rec(std::cerr);
+    FLOG(INFO) {
+      sb << "unpacking inbound message for a new transaction: ";
+      block::gen::t_Message_Any.print_ref(sb, in_msg);
+      load_cell_slice(in_msg).print_rec(sb);
+    };
   }
   auto cs = vm::load_cell_slice(in_msg);
   int tag = block::gen::t_CommonMsgInfo.get_tag(cs);
@@ -1550,11 +1554,13 @@ bool Transaction::run_precompiled_contract(const ComputePhaseConfig& cfg, precom
     cp.actions = impl.get_c5();
     int out_act_num = output_actions_count(cp.actions);
     if (verbosity > 2) {
-      std::cerr << "new smart contract data: ";
-      bool can_be_special = true;
-      load_cell_slice_special(cp.new_data, can_be_special).print_rec(std::cerr);
-      std::cerr << "output actions: ";
-      block::gen::OutList{out_act_num}.print_ref(std::cerr, cp.actions);
+      FLOG(INFO) {
+        sb << "new smart contract data: ";
+        bool can_be_special = true;
+        load_cell_slice_special(cp.new_data, can_be_special).print_rec(sb);
+        sb << "output actions: ";
+        block::gen::OutList{out_act_num}.print_ref(sb, cp.actions);
+      };
     }
   }
   cp.mode = 0;
@@ -1619,7 +1625,6 @@ bool Transaction::prepare_compute_phase(const ComputePhaseConfig& cfg) {
   if (in_msg_state.not_null()) {
     LOG(DEBUG) << "HASH(in_msg_state) = " << in_msg_state->get_hash().bits().to_hex(256)
                << ", account_state_hash = " << account.state_hash.to_hex();
-    // vm::load_cell_slice(in_msg_state).print_rec(std::cerr);
   } else {
     LOG(DEBUG) << "in_msg_state is null";
   }
@@ -1775,11 +1780,13 @@ bool Transaction::prepare_compute_phase(const ComputePhaseConfig& cfg) {
     cp.actions = vm.get_committed_state().c5;   // c5 -> action list
     int out_act_num = output_actions_count(cp.actions);
     if (verbosity > 2) {
-      std::cerr << "new smart contract data: ";
-      bool can_be_special = true;
-      load_cell_slice_special(cp.new_data, can_be_special).print_rec(std::cerr);
-      std::cerr << "output actions: ";
-      block::gen::OutList{out_act_num}.print_ref(std::cerr, cp.actions);
+      FLOG(INFO) {
+        sb << "new smart contract data: ";
+        bool can_be_special = true;
+        load_cell_slice_special(cp.new_data, can_be_special).print_rec(sb);
+        sb << "output actions: ";
+        block::gen::OutList{out_act_num}.print_ref(sb, cp.actions);
+      };
     }
   }
   cp.mode = 0;
@@ -2725,14 +2732,18 @@ int Transaction::try_action_send_msg(const vm::CellSlice& cs0, ActionPhase& ap,
   }
   if (!block::gen::t_Message_Any.validate_ref(new_msg)) {
     LOG(ERROR) << "generated outbound message is not a valid (Message Any) according to automated check";
-    block::gen::t_Message_Any.print_ref(std::cerr, new_msg);
-    vm::load_cell_slice(new_msg).print_rec(std::cerr);
+    FLOG(INFO) {
+      block::gen::t_Message_Any.print_ref(sb, new_msg);
+      vm::load_cell_slice(new_msg).print_rec(sb);
+    };
     collect_fine();
     return -1;
   }
   if (verbosity > 2) {
-    std::cerr << "converted outbound message: ";
-    block::gen::t_Message_Any.print_ref(std::cerr, new_msg);
+    FLOG(INFO) {
+      sb << "converted outbound message: ";
+      block::gen::t_Message_Any.print_ref(sb, new_msg);
+    };
   }
 
   ap.msgs_created++;
@@ -3045,8 +3056,10 @@ bool Transaction::prepare_bounce_phase(const ActionPhaseConfig& cfg) {
   }
   CHECK(cb.finalize_to(bp.out_msg));
   if (verbosity > 2) {
-    LOG(INFO) << "generated bounced message: ";
-    block::gen::t_Message_Any.print_ref(std::cerr, bp.out_msg);
+    FLOG(INFO) {
+      sb << "generated bounced message: ";
+      block::gen::t_Message_Any.print_ref(sb, bp.out_msg);
+    };
   }
   out_msgs.push_back(bp.out_msg);
   bp.ok = true;
@@ -3167,11 +3180,13 @@ bool Transaction::compute_state() {
       auto frozen_state = cb2.finalize();
       frozen_hash = frozen_state->get_hash().bits();
       if (verbosity >= 3 * 1) {  // !!!DEBUG!!!
-        std::cerr << "freezing state of smart contract: ";
-        block::gen::t_StateInit.print_ref(std::cerr, frozen_state);
-        CHECK(block::gen::t_StateInit.validate_ref(frozen_state));
-        CHECK(block::tlb::t_StateInit.validate_ref(frozen_state));
-        std::cerr << "with hash " << frozen_hash.to_hex() << std::endl;
+        FLOG(INFO) {
+          sb << "freezing state of smart contract: ";
+          block::gen::t_StateInit.print_ref(sb, frozen_state);
+          CHECK(block::gen::t_StateInit.validate_ref(frozen_state));
+          CHECK(block::tlb::t_StateInit.validate_ref(frozen_state));
+          sb << "with hash " << frozen_hash.to_hex();
+        };
       }
     }
     new_code.clear();
@@ -3229,8 +3244,10 @@ bool Transaction::compute_state() {
   CHECK(cb.append_data_cell_bool(std::move(storage)));
   new_total_state = cb.finalize();
   if (verbosity > 2) {
-    std::cerr << "new account state: ";
-    block::gen::t_Account.print_ref(std::cerr, new_total_state);
+    FLOG(INFO) {
+      sb << "new account state: ";
+      block::gen::t_Account.print_ref(sb, new_total_state);
+    };
   }
   CHECK(block::tlb::t_Account.validate_ref(new_total_state));
   return true;
@@ -3322,22 +3339,28 @@ bool Transaction::serialize() {
       return false;
   }
   if (verbosity >= 3 * 1) {
-    std::cerr << "new transaction: ";
-    block::gen::t_Transaction.print_ref(std::cerr, root);
-    vm::load_cell_slice(root).print_rec(std::cerr);
+    FLOG(INFO) {
+      sb << "new transaction: ";
+      block::gen::t_Transaction.print_ref(sb, root);
+      vm::load_cell_slice(root).print_rec(sb);
+    };
   }
 
   if (!block::gen::t_Transaction.validate_ref(4096, root)) {
     LOG(ERROR) << "newly-generated transaction failed to pass automated validation:";
-    vm::load_cell_slice(root).print_rec(std::cerr);
-    block::gen::t_Transaction.print_ref(std::cerr, root);
+    FLOG(INFO) {
+      vm::load_cell_slice(root).print_rec(sb);
+      block::gen::t_Transaction.print_ref(sb, root);
+    };
     root.clear();
     return false;
   }
   if (!block::tlb::t_Transaction.validate_ref(4096, root)) {
     LOG(ERROR) << "newly-generated transaction failed to pass hand-written validation:";
-    vm::load_cell_slice(root).print_rec(std::cerr);
-    block::gen::t_Transaction.print_ref(std::cerr, root);
+    FLOG(INFO) {
+      vm::load_cell_slice(root).print_rec(sb);
+      block::gen::t_Transaction.print_ref(sb, root);
+    };
     root.clear();
     return false;
   }

crypto/tl/tlblib.cpp

@@ -196,6 +196,13 @@ bool TLB::print_ref(std::ostream& os, Ref<vm::Cell> cell_ref, int indent, int re
   return pp.fail_unless(print_ref(pp, std::move(cell_ref)));
 }
 
+bool TLB::print_ref(td::StringBuilder& sb, Ref<vm::Cell> cell_ref, int indent, int rec_limit) const {
+  std::ostringstream ss;
+  auto result = print_ref(ss, std::move(cell_ref), indent, rec_limit);
+  sb << ss.str();
+  return result;
+}
+
 std::string TLB::as_string_skip(vm::CellSlice& cs, int indent) const {
   std::ostringstream os;
   print_skip(os, cs, indent);

crypto/tl/tlblib.hpp

@@ -246,7 +246,14 @@ class TLB {
   bool print(std::ostream& os, Ref<vm::CellSlice> cs_ref, int indent = 0, int rec_limit = 0) const {
     return print(os, *cs_ref, indent, rec_limit);
   }
+  bool print(td::StringBuilder& sb, Ref<vm::CellSlice> cs_ref, int indent = 0, int rec_limit = 0) const {
+    std::ostringstream ss;
+    auto result = print(ss, *cs_ref, indent, rec_limit);
+    sb << ss.str();
+    return result;
+  }
   bool print_ref(std::ostream& os, Ref<vm::Cell> cell_ref, int indent = 0, int rec_limit = 0) const;
+  bool print_ref(td::StringBuilder& sb, Ref<vm::Cell> cell_ref, int indent = 0, int rec_limit = 0) const;
   bool print_ref(int rec_limit, std::ostream& os, Ref<vm::Cell> cell_ref, int indent = 0) const {
     return print_ref(os, std::move(cell_ref), indent, rec_limit);
   }

crypto/vm/cells/CellSlice.cpp

@@ -1026,6 +1026,13 @@ bool CellSlice::print_rec(std::ostream& os, int indent) const {
   return print_rec(os, &limit, indent);
 }
 
+bool CellSlice::print_rec(td::StringBuilder& sb, int indent) const {
+  std::ostringstream ss;
+  auto result = print_rec(ss, indent);
+  sb << ss.str();
+  return result;
+}
+
 bool CellSlice::print_rec(int limit, std::ostream& os, int indent) const {
   return print_rec(os, &limit, indent);
 }

crypto/vm/cells/CellSlice.h

@@ -257,6 +257,7 @@ class CellSlice : public td::CntObject {
   void dump(std::ostream& os, int level = 0, bool endl = true) const;
   void dump_hex(std::ostream& os, int mode = 0, bool endl = false) const;
   bool print_rec(std::ostream& os, int indent = 0) const;
+  bool print_rec(td::StringBuilder& sb, int indent = 0) const;
   bool print_rec(std::ostream& os, int* limit, int indent = 0) const;
   bool print_rec(int limit, std::ostream& os, int indent = 0) const;
   void error() const {

overlay/overlay-fec.cpp

@@ -32,7 +32,7 @@ void OverlayOutboundFecBroadcast::alarm() {
                             fec_type_.size(), flags_, std::move(X.data), X.id, fec_type_, date_);
   }
 
-  alarm_timestamp() = td::Timestamp::in(0.010);
+  alarm_timestamp() = td::Timestamp::in(delay_);
 
   if (seqno_ >= to_send_) {
     stop();
@@ -46,8 +46,9 @@ void OverlayOutboundFecBroadcast::start_up() {
 
 OverlayOutboundFecBroadcast::OverlayOutboundFecBroadcast(td::BufferSlice data, td::uint32 flags,
                                                          td::actor::ActorId<OverlayImpl> overlay,
-                                                         PublicKeyHash local_id)
+                                                         PublicKeyHash local_id, double speed_multiplier)
     : flags_(flags) {
+  delay_ /= speed_multiplier;
   CHECK(data.size() <= (1 << 27));
   local_id_ = local_id;
   overlay_ = std::move(overlay);
@@ -63,9 +64,10 @@ OverlayOutboundFecBroadcast::OverlayOutboundFecBroadcast(td::BufferSlice data, t
 }
 
 td::actor::ActorId<OverlayOutboundFecBroadcast> OverlayOutboundFecBroadcast::create(
-    td::BufferSlice data, td::uint32 flags, td::actor::ActorId<OverlayImpl> overlay, PublicKeyHash local_id) {
-  return td::actor::create_actor<OverlayOutboundFecBroadcast>(td::actor::ActorOptions().with_name("bcast"),
-                                                              std::move(data), flags, overlay, local_id)
+    td::BufferSlice data, td::uint32 flags, td::actor::ActorId<OverlayImpl> overlay, PublicKeyHash local_id,
+    double speed_multiplier) {
+  return td::actor::create_actor<OverlayOutboundFecBroadcast>(
+             td::actor::ActorOptions().with_name("bcast"), std::move(data), flags, overlay, local_id, speed_multiplier)
       .release();
 }
 

overlay/overlay-fec.hpp

@@ -37,6 +37,7 @@ class OverlayOutboundFecBroadcast : public td::actor::Actor {
   PublicKeyHash local_id_;
   Overlay::BroadcastDataHash data_hash_;
   td::uint32 flags_ = 0;
+  double delay_ = 0.010;
   td::int32 date_;
   std::unique_ptr<td::fec::Encoder> encoder_;
   td::actor::ActorId<OverlayImpl> overlay_;
@@ -45,9 +46,9 @@ class OverlayOutboundFecBroadcast : public td::actor::Actor {
  public:
   static td::actor::ActorId<OverlayOutboundFecBroadcast> create(td::BufferSlice data, td::uint32 flags,
                                                                 td::actor::ActorId<OverlayImpl> overlay,
-                                                                PublicKeyHash local_id);
+                                                                PublicKeyHash local_id, double speed_multiplier = 1.0);
   OverlayOutboundFecBroadcast(td::BufferSlice data, td::uint32 flags, td::actor::ActorId<OverlayImpl> overlay,
-                              PublicKeyHash local_id);
+                              PublicKeyHash local_id, double speed_multiplier = 1.0);
 
   void alarm() override;
   void start_up() override;

overlay/overlay.cpp

@@ -63,7 +63,7 @@ td::actor::ActorOwn<Overlay> Overlay::create_private(
   return td::actor::create_actor<OverlayImpl>(
       overlay_actor_name(overlay_id), keyring, adnl, manager, dht_node, local_id, std::move(overlay_id),
       OverlayType::FixedMemberList, std::move(nodes), std::vector<PublicKeyHash>(), OverlayMemberCertificate{},
-      std::move(callback), std::move(rules), std::move(scope));
+      std::move(callback), std::move(rules), std::move(scope), std::move(opts));
 }
 
 td::actor::ActorOwn<Overlay> Overlay::create_semiprivate(
@@ -99,6 +99,7 @@ OverlayImpl::OverlayImpl(td::actor::ActorId<keyring::Keyring> keyring, td::actor
   overlay_id_ = id_full_.compute_short_id();
   frequent_dht_lookup_ = opts_.frequent_dht_lookup_;
   peer_list_.local_member_flags_ = opts_.local_overlay_member_flags_;
+  opts_.broadcast_speed_multiplier_ = std::max(opts_.broadcast_speed_multiplier_, 1e-9);
 
   VLOG(OVERLAY_INFO) << this << ": creating";
 
@@ -490,7 +491,8 @@ void OverlayImpl::send_broadcast_fec(PublicKeyHash send_as, td::uint32 flags, td
     VLOG(OVERLAY_WARNING) << "broadcast source certificate is invalid";
     return;
   }
-  OverlayOutboundFecBroadcast::create(std::move(data), flags, actor_id(this), send_as);
+  OverlayOutboundFecBroadcast::create(std::move(data), flags, actor_id(this), send_as,
+                                      opts_.broadcast_speed_multiplier_);
 }
 
 void OverlayImpl::print(td::StringBuilder &sb) {

overlay/overlays.h

@@ -269,6 +269,7 @@ struct OverlayOptions {
   td::uint32 nodes_to_send_ = 4;
   td::uint32 propagate_broadcast_to_ = 5;
   td::uint32 default_permanent_members_flags_ = 0;
+  double broadcast_speed_multiplier_ = 1.0;
 };
 
 class Overlays : public td::actor::Actor {