new routing exchange prototype using IBF (near#4112)

Implement new algorithm for exchanging routing tables using Inverse Bloom Filters.
near#3838

Reposting near#4108

chain/chain/Cargo.toml

@@ -44,6 +44,7 @@ delay_detector = ["delay-detector"]
 no_cache = ["near-store/no_cache"]
 protocol_feature_block_header_v3 = []
 protocol_feature_chunk_only_producers = ["protocol_feature_block_header_v3", "near-primitives/protocol_feature_chunk_only_producers"]
-nightly_protocol_features = ["nightly_protocol", "protocol_feature_block_header_v3", "protocol_feature_chunk_only_producers"]
+protocol_feature_routing_exchange_algorithm = []
+nightly_protocol_features = ["nightly_protocol", "protocol_feature_block_header_v3", "protocol_feature_chunk_only_producers", "protocol_feature_routing_exchange_algorithm"]
 nightly_protocol = []
 sandbox = []

chain/client/Cargo.toml

@@ -55,6 +55,7 @@ adversarial = ["near-network/adversarial", "near-chain/adversarial"]
 delay_detector = ["near-chain/delay_detector", "near-network/delay_detector", "delay-detector"]
 protocol_feature_block_header_v3 = ["near-primitives/protocol_feature_block_header_v3", "near-chain/protocol_feature_block_header_v3", "near-store/protocol_feature_block_header_v3"]
 protocol_feature_chunk_only_producers = ["protocol_feature_block_header_v3", "near-primitives/protocol_feature_chunk_only_producers", "near-chain/protocol_feature_chunk_only_producers"]
+protocol_feature_routing_exchange_algorithm = []
 nightly_protocol = []
-nightly_protocol_features = ["nightly_protocol", "near-chain/nightly_protocol_features", "protocol_feature_block_header_v3"]
+nightly_protocol_features = ["nightly_protocol", "near-chain/nightly_protocol_features", "protocol_feature_block_header_v3", "protocol_feature_routing_exchange_algorithm"]
 sandbox = ["near-network/sandbox", "near-chain/sandbox"]

chain/client/src/sync.rs

@@ -1217,7 +1217,6 @@ mod test {
     use near_chain::test_utils::{setup, setup_with_validators};
     use near_chain::{ChainGenesis, Provenance};
     use near_crypto::{KeyType, PublicKey};
-    use near_network::routing::EdgeInfo;
     use near_network::test_utils::MockNetworkAdapter;
     use near_network::types::PeerChainInfoV2;
     use near_network::PeerInfo;
@@ -1226,6 +1225,7 @@ mod test {
 
     use super::*;
     use crate::test_utils::TestEnv;
+    use near_network::routing::EdgeInfo;
     use near_primitives::merkle::PartialMerkleTree;
     use near_primitives::types::EpochId;
     use near_primitives::validator_signer::InMemoryValidatorSigner;

chain/client/src/test_utils.rs

@@ -2,14 +2,17 @@ use log::info;
 use std::cmp::max;
 use std::collections::{HashMap, HashSet};
 use std::convert::TryFrom;
+use std::mem::swap;
 use std::ops::DerefMut;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
+use std::time::Instant;
 
 use actix::actors::mocker::Mocker;
 use actix::{Actor, Addr, AsyncContext, Context};
 use chrono::{DateTime, Utc};
 use futures::{future, FutureExt};
+use num_rational::Rational;
 use rand::{thread_rng, Rng};
 
 use near_chain::test_utils::KeyValueRuntime;
@@ -19,6 +22,7 @@ use near_chain::{
 use near_chain_configs::ClientConfig;
 use near_crypto::{InMemorySigner, KeyType, PublicKey};
 use near_network::routing::EdgeInfo;
+use near_network::test_utils::MockNetworkAdapter;
 use near_network::types::{
     AccountOrPeerIdOrHash, NetworkInfo, NetworkViewClientMessages, NetworkViewClientResponses,
     PeerChainInfoV2,
@@ -29,6 +33,10 @@ use near_network::{
 };
 use near_primitives::block::{ApprovalInner, Block, GenesisId};
 use near_primitives::hash::{hash, CryptoHash};
+use near_primitives::merkle::{merklize, MerklePath};
+use near_primitives::receipt::Receipt;
+use near_primitives::shard_layout::ShardUId;
+use near_primitives::sharding::{EncodedShardChunk, ReedSolomonWrapper};
 use near_primitives::transaction::SignedTransaction;
 use near_primitives::types::{
     AccountId, Balance, BlockHeight, BlockHeightDelta, NumBlocks, NumSeats, NumShards,
@@ -43,15 +51,6 @@ use near_telemetry::TelemetryActor;
 #[cfg(feature = "adversarial")]
 use crate::AdversarialControls;
 use crate::{start_view_client, Client, ClientActor, SyncStatus, ViewClientActor};
-use near_network::test_utils::MockNetworkAdapter;
-use near_primitives::merkle::{merklize, MerklePath};
-use near_primitives::receipt::Receipt;
-use near_primitives::shard_layout::ShardUId;
-use near_primitives::sharding::{EncodedShardChunk, ReedSolomonWrapper};
-use num_rational::Rational;
-use std::mem::swap;
-use std::time::Instant;
-
 pub type NetworkMock = Mocker<PeerManagerActor>;
 
 /// Sets up ClientActor and ViewClientActor viewing the same store/runtime.
@@ -964,6 +963,8 @@ pub fn setup_mock_all_validators(
                         | NetworkRequests::RequestUpdateNonce(_, _)
                         | NetworkRequests::ResponseUpdateNonce(_)
                         | NetworkRequests::ReceiptOutComeRequest(_, _) => {}
+                        #[cfg(feature = "protocol_feature_routing_exchange_algorithm")]
+                        | NetworkRequests::IbfMessage { .. } => {}
                     };
                 }
                 Box::new(Some(resp))

chain/jsonrpc-primitives/Cargo.toml

@@ -22,6 +22,7 @@ near-metrics = { path = "../../core/metrics" }
 near-primitives = { path = "../../core/primitives" }
 near-primitives-core = { path = "../../core/primitives-core" }
 near-rpc-error-macro = { path = "../../tools/rpctypegen/macro" }
+near-network = { path = "../network", optional=true }
 
 [features]
-adversarial = []
+adversarial = ["near-network"]

chain/jsonrpc-primitives/src/types/adversarial.rs

@@ -0,0 +1,35 @@
+use crate::errors::RpcError;
+use near_network::routing::{Edge, SimpleEdge};
+use near_primitives::network::PeerId;
+use serde::Deserialize;
+use serde_json::Value;
+
+#[derive(Deserialize)]
+pub struct SetRoutingTableRequest {
+    pub add_edges: Option<Vec<Edge>>,
+    pub remove_edges: Option<Vec<SimpleEdge>>,
+    pub prune_edges: Option<bool>,
+}
+
+impl SetRoutingTableRequest {
+    pub fn parse(value: Option<Value>) -> Result<Self, RpcError> {
+        if let Some(value) = value {
+            serde_json::from_value(value)
+                .map_err(|err| RpcError::parse_error(format!("Error {:?}", err)))
+        } else {
+            Err(RpcError::parse_error("Require at least one parameter".to_owned()))
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct SetAdvOptionsRequest {
+    pub disable_edge_signature_verification: Option<bool>,
+    pub disable_edge_propagation: Option<bool>,
+    pub disable_edge_pruning: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub struct StartRoutingTableSyncRequest {
+    pub peer_id: PeerId,
+}

chain/jsonrpc-primitives/src/types/mod.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "adversarial")]
+pub mod adversarial;
 pub mod blocks;
 pub mod changes;
 pub mod chunks;

chain/jsonrpc/src/lib.rs

@@ -21,12 +21,21 @@ use near_client::{
 pub use near_jsonrpc_client as client;
 use near_jsonrpc_primitives::errors::RpcError;
 use near_jsonrpc_primitives::message::{Message, Request};
+#[cfg(feature = "adversarial")]
+use near_jsonrpc_primitives::types::adversarial::{
+    SetAdvOptionsRequest, SetRoutingTableRequest, StartRoutingTableSyncRequest,
+};
 use near_jsonrpc_primitives::types::config::RpcProtocolConfigResponse;
 use near_metrics::{Encoder, TextEncoder};
 #[cfg(feature = "adversarial")]
-use near_network::types::{NetworkAdversarialMessage, NetworkViewClientMessages};
+use near_network::types::{
+    GetPeerId, GetRoutingTable, NetworkAdversarialMessage, NetworkViewClientMessages,
+    SetAdvOptions, SetRoutingTable, StartRoutingTableSync,
+};
 #[cfg(feature = "sandbox")]
 use near_network::types::{NetworkSandboxMessage, SandboxResponse};
+#[cfg(feature = "adversarial")]
+use near_network::PeerManagerActor;
 use near_network::{NetworkClientMessages, NetworkClientResponses};
 use near_primitives::hash::CryptoHash;
 use near_primitives::serialize::BaseEncode;
@@ -201,6 +210,8 @@ struct JsonRpcHandler {
     view_client_addr: Addr<ViewClientActor>,
     polling_config: RpcPollingConfig,
     genesis_config: GenesisConfig,
+    #[cfg(feature = "adversarial")]
+    peer_manager_addr: Addr<PeerManagerActor>,
 }
 
 impl JsonRpcHandler {
@@ -236,6 +247,63 @@ impl JsonRpcHandler {
                 "adv_switch_to_height" => Some(self.adv_switch_to_height(params).await),
                 "adv_get_saved_blocks" => Some(self.adv_get_saved_blocks(params).await),
                 "adv_check_store" => Some(self.adv_check_store(params).await),
+                "adv_set_options" => {
+                    let params = parse_params::<SetAdvOptionsRequest>(params)?;
+                    let result = self
+                        .peer_manager_addr
+                        .send(SetAdvOptions {
+                            disable_edge_signature_verification: params
+                                .disable_edge_signature_verification,
+                            disable_edge_propagation: params.disable_edge_propagation,
+                            disable_edge_pruning: params.disable_edge_pruning,
+                        })
+                        .await?;
+                    Some(
+                        serde_json::to_value(result)
+                            .map_err(|err| RpcError::serialization_error(err.to_string())),
+                    )
+                }
+                "adv_set_routing_table" => {
+                    let request = SetRoutingTableRequest::parse(params)?;
+                    let result = self
+                        .peer_manager_addr
+                        .send(SetRoutingTable {
+                            add_edges: request.add_edges,
+                            remove_edges: request.remove_edges,
+                            prune_edges: request.prune_edges,
+                        })
+                        .await?;
+                    Some(
+                        serde_json::to_value(result)
+                            .map_err(|err| RpcError::serialization_error(err.to_string())),
+                    )
+                }
+                "adv_start_routing_table_syncv2" => {
+                    let params = parse_params::<StartRoutingTableSyncRequest>(params)?;
+
+                    let result = self
+                        .peer_manager_addr
+                        .send(StartRoutingTableSync { peer_id: params.peer_id })
+                        .await?;
+                    Some(
+                        serde_json::to_value(result)
+                            .map_err(|err| RpcError::serialization_error(err.to_string())),
+                    )
+                }
+                "adv_get_peer_id" => {
+                    let response = self.peer_manager_addr.send(GetPeerId {}).await?;
+                    Some(
+                        serde_json::to_value(response)
+                            .map_err(|err| RpcError::serialization_error(err.to_string())),
+                    )
+                }
+                "adv_get_routing_table" => {
+                    let result = self.peer_manager_addr.send(GetRoutingTable {}).await?;
+                    Some(
+                        serde_json::to_value(result)
+                            .map_err(|err| RpcError::serialization_error(err.to_string())),
+                    )
+                }
                 _ => None,
             };
 
@@ -1218,6 +1286,7 @@ pub fn start_http(
     genesis_config: GenesisConfig,
     client_addr: Addr<ClientActor>,
     view_client_addr: Addr<ViewClientActor>,
+    #[cfg(feature = "adversarial")] peer_manager_addr: Addr<PeerManagerActor>,
 ) -> Vec<(&'static str, actix_web::dev::Server)> {
     let RpcConfig { addr, prometheus_addr, cors_allowed_origins, polling_config, limits_config } =
         config;
@@ -1233,6 +1302,8 @@ pub fn start_http(
                 view_client_addr: view_client_addr.clone(),
                 polling_config,
                 genesis_config: genesis_config.clone(),
+                #[cfg(feature = "adversarial")]
+                peer_manager_addr: peer_manager_addr.clone(),
             })
             .app_data(web::JsonConfig::default().limit(limits_config.json_payload_max_size))
             .wrap(middleware::Logger::default())

chain/jsonrpc/test-utils/Cargo.toml

@@ -13,3 +13,6 @@ near-primitives = { path = "../../../core/primitives" }
 near-client = { path = "../../client" }
 near-network = { path = "../../network" }
 near-jsonrpc = { path = "../" }
+
+[features]
+adversarial = []

chain/jsonrpc/test-utils/src/lib.rs

@@ -1,9 +1,13 @@
+#[cfg(feature = "adversarial")]
+use actix::Actor;
 use actix::Addr;
 
 use near_chain_configs::GenesisConfig;
 use near_client::test_utils::setup_no_network_with_validity_period_and_no_epoch_sync;
 use near_client::ViewClientActor;
 use near_jsonrpc::{start_http, RpcConfig};
+#[cfg(feature = "adversarial")]
+use near_network::test_utils::make_peer_manager;
 use near_network::test_utils::open_port;
 use near_primitives::types::NumBlocks;
 
@@ -39,12 +43,16 @@ pub fn start_all_with_validity_period_and_no_epoch_sync(
     );
 
     let addr = format!("127.0.0.1:{}", open_port());
-
+    #[cfg(feature = "adversarial")]
+    let peer_manager_addr =
+        make_peer_manager("test2", open_port(), vec![("test1", open_port())], 10).0.start();
     start_http(
         RpcConfig::new(&addr),
         TEST_GENESIS_CONFIG.clone(),
         client_addr.clone(),
         view_client_addr.clone(),
+        #[cfg(feature = "adversarial")]
+        peer_manager_addr,
     );
     (view_client_addr, addr)
 }

chain/jsonrpc/tests/test_utils/mod.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "adversarial")]
+use actix::Actor;
 use actix::Addr;
 use futures::{future, future::LocalBoxFuture, FutureExt, TryFutureExt};
 use serde_json::json;
@@ -6,11 +8,12 @@ use near_chain_configs::GenesisConfig;
 use near_client::test_utils::setup_no_network_with_validity_period_and_no_epoch_sync;
 use near_client::ViewClientActor;
 use near_jsonrpc::{start_http, RpcConfig};
+use near_jsonrpc_primitives::message::{from_slice, Message};
+#[cfg(feature = "adversarial")]
+use near_network::test_utils::make_peer_manager;
 use near_network::test_utils::open_port;
 use near_primitives::types::NumBlocks;
 
-use near_jsonrpc_primitives::message::{from_slice, Message};
-
 lazy_static::lazy_static! {
     pub static ref TEST_GENESIS_CONFIG: GenesisConfig =
         GenesisConfig::from_json(include_str!("../../../../nearcore/res/genesis_config.json"));
@@ -44,11 +47,17 @@ pub fn start_all_with_validity_period_and_no_epoch_sync(
 
     let addr = format!("127.0.0.1:{}", open_port());
 
+    #[cfg(feature = "adversarial")]
+    let peer_manager_addr =
+        make_peer_manager("test2", open_port(), vec![("test1", open_port())], 10).0.start();
+
     start_http(
         RpcConfig::new(&addr),
         TEST_GENESIS_CONFIG.clone(),
         client_addr.clone(),
         view_client_addr.clone(),
+        #[cfg(feature = "adversarial")]
+        peer_manager_addr,
     );
     (view_client_addr, addr)
 }