Merge branch 'main' into rpc_test_layer

Dockerfile

@@ -3,7 +3,7 @@ FROM rust:latest as build
 COPY /node/ /node/
 COPY Makefile .
 WORKDIR /node
-RUN apt-get update && apt-get install -y libclang-dev protobuf-compiler libprotobuf-dev
+RUN apt-get update && apt-get install -y libclang-dev
 RUN cargo build --release
 RUN cd .. && make docker_node_configs
 

node/actors/network/src/mux/mod.rs

@@ -2,7 +2,7 @@
 //! over a single transport stream. Single multiplexer may define multiple internal endpoints (aka
 //! "capabilities"). When establishing a new transient substream (via accept/connect methods)
 //! you need to specify a capability: if peer A calls `mux.connect(ctx,x)` then peer B needs to
-//! call `mux.accept(ctx,x)` to accept A's substream (x is the capabilitiy and it has
+//! call `mux.accept(ctx,x)` to accept A's substream (x is the capability and it has
 //! to match on both sides of the connection).
 //!
 //! It currently doesn't prevent head-of-line blocking,

node/actors/network/src/preface.rs

@@ -6,7 +6,7 @@
 //! 4. client and server start endpoint-specific communication.
 //!
 //! Hence, the preface protocol is used to enable encryption
-//! and multiplex between mutliple endpoints available on the same TCP port.
+//! and multiplex between multiple endpoints available on the same TCP port.
 use crate::{frame, metrics, noise, proto::preface as proto};
 use zksync_concurrency::{ctx, time};
 use zksync_protobuf::{required, ProtoFmt};

node/libs/concurrency/src/scope/mod.rs

@@ -101,7 +101,7 @@ impl<'env, T> JoinHandle<'env, T> {
     /// Panics if the awaited task panicked.
     ///
     /// Caller is expected to provide their local context as an argument, which
-    /// is neccessarily a descendant of the scope's context (because JoinHandle cannot
+    /// is necessarily a descendant of the scope's context (because JoinHandle cannot
     /// leave the scope's lifetime). There might arise a race condition between
     /// the cancelation of `ctx` and termination of the task, in which case
     /// we await cancelation of `ctx` explicitly, so that the race condition is not
@@ -219,7 +219,7 @@ impl<'env, E: 'static + Send> Scope<'env, E> {
     /// before the context is canceled.
     /// You can use this method if you want to cancel immediately without
     /// returning an error (so that the whole scope can actually terminate
-    /// succesfully).
+    /// successfully).
     pub fn cancel(&self) {
         self.ctx.cancel();
     }

node/libs/concurrency/src/scope/task.rs

@@ -18,7 +18,7 @@
 //!
 //! NOTE: although background tasks are not considered to be doing the "work of the scope" they
 //! are still required to complete gracefully once the scope gets canceled: if all main tasks
-//! complete succesfully, and one of the background tasks returns an error afterwards,
+//! complete successfully, and one of the background tasks returns an error afterwards,
 //! `scope::run!` will still return an error.
 //!
 //! NOTE: although background tasks shouldn't spawn main tasks, the current API of `Scope`

node/libs/concurrency/src/scope/tests.rs

@@ -81,7 +81,7 @@ fn test_already_canceled() {
     });
 }
 
-// After all main tasks complete succesfully, the scope gets canceled.
+// After all main tasks complete successfully, the scope gets canceled.
 // Background tasks of the scope should still be able to spawn more tasks
 // both via `Scope::spawn()` and `Scope::spawn_bg` (although after scope
 // cancelation they behave exactly the same).

node/libs/storage/src/block_store/mod.rs

@@ -32,11 +32,11 @@ impl BlockStoreState {
 /// Implementations **must** propagate context cancellation using [`StorageError::Canceled`].
 #[async_trait::async_trait]
 pub trait PersistentBlockStore: fmt::Debug + Send + Sync {
-    /// Range of blocks avaliable in storage.
+    /// Range of blocks available in storage.
     /// PersistentBlockStore is expected to always contain at least 1 block,
     /// and be append-only storage (never delete blocks).
     /// Consensus code calls this method only once and then tracks the
-    /// range of avaliable blocks internally.
+    /// range of available blocks internally.
     async fn state(&self, ctx: &ctx::Ctx) -> ctx::Result<BlockStoreState>;
 
     /// Gets a block by its number.