Merge pull request #1139 from ton-blockchain/stable_testnet

Merge recent updates

Author: EmelyanenkoK

.github/workflows/docker-ubuntu-branch-image.yml

@@ -0,0 +1,48 @@
+name: Docker Ubuntu 22.04 branch image
+
+on:
+  workflow_dispatch:
+  push:
+    branches-ignore:
+      - master
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get tag as branch name
+        id: tag
+        run: |
+          echo "TAG=${GITHUB_REF##*/}" >> $GITHUB_OUTPUT
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64
+          push: true
+          context: ./
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.tag.outputs.TAG }}

Dockerfile

@@ -27,14 +27,18 @@ RUN apt-get update && \
     apt-get install -y wget curl libatomic1 openssl libsecp256k1-dev libsodium-dev libmicrohttpd-dev liblz4-dev libjemalloc-dev htop net-tools netcat iptraf-ng jq tcpdump pv plzip && \
     rm -rf /var/lib/apt/lists/*
 
-RUN mkdir -p /var/ton-work/db /var/ton-work/scripts
+RUN mkdir -p /var/ton-work/db /var/ton-work/scripts /usr/share/ton/smartcont/ /usr/lib/fift/
 
 COPY --from=builder /ton/build/storage/storage-daemon/storage-daemon /usr/local/bin/
 COPY --from=builder /ton/build/storage/storage-daemon/storage-daemon-cli /usr/local/bin/
 COPY --from=builder /ton/build/lite-client/lite-client /usr/local/bin/
 COPY --from=builder /ton/build/validator-engine/validator-engine /usr/local/bin/
 COPY --from=builder /ton/build/validator-engine-console/validator-engine-console /usr/local/bin/
 COPY --from=builder /ton/build/utils/generate-random-id /usr/local/bin/
+COPY --from=builder /ton/build/crypto/fift /usr/local/bin/
+COPY --from=builder /ton/build/crypto/func /usr/local/bin/
+COPY --from=builder /ton/crypto/smartcont/* /usr/share/ton/smartcont/
+COPY --from=builder /ton/crypto/fift/lib/* /usr/lib/fift/
 
 WORKDIR /var/ton-work/db
 COPY ./docker/init.sh ./docker/control.template /var/ton-work/scripts/

adnl/adnl-peer.cpp

@@ -269,7 +269,11 @@ void AdnlPeerPairImpl::send_messages_in(std::vector<OutboundAdnlMessage> message
     size_t ptr = 0;
     bool first = true;
     do {
+      respond_with_nop_after_ = td::Timestamp::in(td::Random::fast(1.0, 2.0));
       bool try_reinit = try_reinit_at_ && try_reinit_at_.is_in_past();
+      if (try_reinit) {
+        try_reinit_at_ = td::Timestamp::in(td::Random::fast(0.5, 1.5));
+      }
       bool via_channel = channel_ready_ && !try_reinit;
       size_t s = (via_channel ? channel_packet_header_max_size() : packet_header_max_size());
       if (first) {
@@ -504,12 +508,6 @@ void AdnlPeerPairImpl::create_channel(pubkeys::Ed25519 pub, td::uint32 date) {
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageCreateChannel &message) {
   create_channel(message.key(), message.date());
-  if (respond_to_channel_create_after_.is_in_past()) {
-    respond_to_channel_create_after_ = td::Timestamp::in(td::Random::fast(1.0, 2.0));
-    std::vector<OutboundAdnlMessage> messages;
-    messages.emplace_back(adnlmessage::AdnlMessageNop{}, 0);
-    send_messages(std::move(messages));
-  }
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageConfirmChannel &message) {
@@ -526,6 +524,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageConfirmChan
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageCustom &message) {
+  respond_with_nop();
   td::actor::send_closure(local_actor_, &AdnlLocalId::deliver, peer_id_short_, message.data());
 }
 
@@ -538,6 +537,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageReinit &mes
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &message) {
+  respond_with_nop();
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), query_id = message.query_id(),
                                        flags = static_cast<td::uint32>(0)](td::Result<td::BufferSlice> R) {
     if (R.is_error()) {
@@ -556,6 +556,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &mess
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &message) {
+  respond_with_nop();
   auto Q = out_queries_.find(message.query_id());
 
   if (Q == out_queries_.end()) {
@@ -573,6 +574,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &mes
 }
 
 void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessagePart &message) {
+  respond_with_nop();
   auto size = message.total_size();
   if (size > huge_packet_max_size()) {
     VLOG(ADNL_WARNING) << this << ": dropping too big huge message: size=" << size;
@@ -635,6 +637,14 @@ void AdnlPeerPairImpl::delete_query(AdnlQueryId id) {
   }
 }
 
+void AdnlPeerPairImpl::respond_with_nop() {
+  if (respond_with_nop_after_.is_in_past()) {
+    std::vector<OutboundAdnlMessage> messages;
+    messages.emplace_back(adnlmessage::AdnlMessageNop{}, 0);
+    send_messages(std::move(messages));
+  }
+}
+
 void AdnlPeerPairImpl::reinit(td::int32 date) {
   if (reinit_date_ == 0) {
     reinit_date_ = date;

adnl/adnl-peer.hpp

@@ -122,6 +122,7 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   }
 
  private:
+  void respond_with_nop();
   void reinit(td::int32 date);
   td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> get_conn(bool direct_only);
   void create_channel(pubkeys::Ed25519 pub, td::uint32 date);
@@ -214,7 +215,7 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   pubkeys::Ed25519 channel_pub_;
   td::int32 channel_pk_date_;
   td::actor::ActorOwn<AdnlChannel> channel_;
-  td::Timestamp respond_to_channel_create_after_;
+  td::Timestamp respond_with_nop_after_;
 
   td::uint64 in_seqno_ = 0;
   td::uint64 out_seqno_ = 0;

assembly/wasm/fift-func-wasm-build-ubuntu.sh

@@ -85,7 +85,7 @@ cd ..
 if [ ! -f "openssl/openssl_em" ]; then
   cd openssl
   make clean
-  emconfigure ./Configure linux-generic32 no-shared no-dso no-engine no-unit-test
+  emconfigure ./Configure linux-generic32 no-shared no-dso no-engine no-unit-test no-tests no-fuzz-afl no-fuzz-libfuzzer
   sed -i 's/CROSS_COMPILE=.*/CROSS_COMPILE=/g' Makefile
   sed -i 's/-ldl//g' Makefile
   sed -i 's/-O3/-Os/g' Makefile

catchain/catchain-receiver-source.h

@@ -61,7 +61,7 @@ class CatChainReceiverSource {
   virtual td::BufferSlice fork_proof() const = 0;
   virtual bool fork_is_found() const = 0;
 
-  // One block can be sent to one node only a limited number of times to prevent DoS
+  // One block can be sent to one node in catchain.getDifference only a limited number of times to prevent DoS
   virtual bool allow_send_block(CatChainBlockHash hash) = 0;
 
   static td::Result<std::unique_ptr<CatChainReceiverSource>> create(CatChainReceiver *chain, PublicKey pub_key,

catchain/catchain-receiver.cpp

@@ -697,12 +697,8 @@ void CatChainReceiverImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::cat
   } else {
     CatChainReceiverSource *S = get_source_by_adnl_id(src);
     CHECK(S != nullptr);
-    if (S->allow_send_block(it->second->get_hash())) {
-      promise.set_value(serialize_tl_object(create_tl_object<ton_api::catchain_blockResult>(it->second->export_tl()),
-                                            true, it->second->get_payload().as_slice()));
-    } else {
-      promise.set_error(td::Status::Error("block was requested too many times"));
-    }
+    promise.set_value(serialize_tl_object(create_tl_object<ton_api::catchain_blockResult>(it->second->export_tl()),
+                                          true, it->second->get_payload().as_slice()));
   }
 }
 

catchain/catchain.h

@@ -96,6 +96,7 @@ class CatChain : public td::actor::Actor {
   virtual void send_query_via(const PublicKeyHash &dst, std::string name, td::Promise<td::BufferSlice> promise,
                               td::Timestamp timeout, td::BufferSlice query, td::uint64 max_answer_size,
                               td::actor::ActorId<adnl::AdnlSenderInterface> via) = 0;
+  virtual void get_source_heights(td::Promise<std::vector<CatChainBlockHeight>> promise) = 0;
   virtual void destroy() = 0;
 
   static td::actor::ActorOwn<CatChain> create(std::unique_ptr<Callback> callback, const CatChainOptions &opts,

catchain/catchain.hpp

@@ -115,6 +115,15 @@ class CatChainImpl : public CatChain {
     td::actor::send_closure(receiver_, &CatChainReceiverInterface::send_custom_query_data_via, dst, name,
                             std::move(promise), timeout, std::move(query), max_answer_size, via);
   }
+  void get_source_heights(td::Promise<std::vector<CatChainBlockHeight>> promise) override {
+    std::vector<CatChainBlockHeight> heights(top_source_blocks_.size(), 0);
+    for (size_t i = 0; i < top_source_blocks_.size(); ++i) {
+      if (top_source_blocks_[i]) {
+        heights[i] = top_source_blocks_[i]->height();
+      }
+    }
+    promise.set_result(std::move(heights));
+  }
   void destroy() override;
   CatChainImpl(std::unique_ptr<Callback> callback, const CatChainOptions &opts,
                td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,

crypto/vm/bls.cpp

@@ -93,12 +93,13 @@ bool aggregate_verify(const std::vector<std::pair<P1, td::BufferSlice>> &pubs_ms
       return false;
     }
     std::unique_ptr<blst::Pairing> pairing = std::make_unique<blst::Pairing>(true, DST);
+    blst::P2_Affine p2_zero;
     for (const auto &p : pubs_msgs) {
       blst::P1_Affine p1(p.first.data(), P1_SIZE);
       if (!p1.in_group() || p1.is_inf()) {
         return false;
       }
-      pairing->aggregate(&p1, nullptr, (const td::uint8 *)p.second.data(), p.second.size());
+      pairing->aggregate(&p1, &p2_zero, (const td::uint8 *)p.second.data(), p.second.size());
     }
     pairing->commit();
     blst::P2_Affine p2(sig.data(), P2_SIZE);