Validator DHT (#494)

* Route validators for any active set through sc-authority-discovery

Additionally adds an RPC route to retrieve their P2P addresses.

* Have the coordinator get peers from substrate

* Have the RPC return one address, not up to 3

Prevents the coordinator from believing it has 3 peers when it has one.

* Add missing feature to serai-client

* Correct network argument in serai-client for p2p_validators call

* Add a test in serai-client to check DHT population with a much quicker failure than the coordinator tests

* Update to latest Substrate

Removes distinguishing BABE/AuthorityDiscovery keys which causes
sc_authority_discovery to populate as desired.

* Update to a properly tagged substrate commit

* Add all dialed to peers to GossipSub

* cargo fmt

* Reduce common code in serai-coordinator-tests with amore involved new_test

* Use a recursive async function to spawn `n` DockerTests with the necessary networking configuration

* Merge UNIQUE_ID and ONE_AT_A_TIME

* Tidy up the new recursive code in tests/coordinator

* Use a Mutex in CONTEXT to let it be set multiple times

* Make complimentary edits to full-stack tests

* Augment coordinator P2p connection logs

* Drop lock acquisitions before recursing

* Better scope lock acquisitions in full-stack, preventing a deadlock

* Ensure OUTER_OPS is reset across the test boundary

* Add cargo deny allowance for dockertest fork

substrate/node/src/rpc.rs

@@ -1,16 +1,18 @@
-use std::sync::Arc;
-
-use jsonrpsee::RpcModule;
+use std::{sync::Arc, collections::HashSet};
 
 use sp_blockchain::{Error as BlockchainError, HeaderBackend, HeaderMetadata};
 use sp_block_builder::BlockBuilder;
 use sp_api::ProvideRuntimeApi;
 
 use serai_runtime::{
-  primitives::{SubstrateAmount, PublicKey},
-  Nonce, Block,
+  primitives::{NetworkId, SubstrateAmount, PublicKey},
+  Nonce, Block, SeraiRuntimeApi,
 };
 
+use tokio::sync::RwLock;
+
+use jsonrpsee::RpcModule;
+
 pub use sc_rpc_api::DenyUnsafe;
 use sc_transaction_pool_api::TransactionPool;
 
@@ -18,6 +20,7 @@ pub struct FullDeps<C, P> {
   pub client: Arc<C>,
   pub pool: Arc<P>,
   pub deny_unsafe: DenyUnsafe,
+  pub authority_discovery: Option<sc_authority_discovery::Service>,
 }
 
 pub fn create_full<
@@ -34,16 +37,56 @@ pub fn create_full<
 where
   C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, PublicKey, Nonce>
     + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, SubstrateAmount>
+    + SeraiRuntimeApi<Block>
     + BlockBuilder<Block>,
 {
   use substrate_frame_rpc_system::{System, SystemApiServer};
   use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
 
   let mut module = RpcModule::new(());
-  let FullDeps { client, pool, deny_unsafe } = deps;
+  let FullDeps { client, pool, deny_unsafe, authority_discovery } = deps;
 
   module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?;
-  module.merge(TransactionPayment::new(client).into_rpc())?;
+  module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
+
+  if let Some(authority_discovery) = authority_discovery {
+    let mut authority_discovery_module = RpcModule::new((client, RwLock::new(authority_discovery)));
+    authority_discovery_module.register_async_method(
+      "p2p_validators",
+      |params, context| async move {
+        let network: NetworkId = params.parse()?;
+        let (client, authority_discovery) = &*context;
+        let latest_block = client.info().best_hash;
+
+        let validators = client.runtime_api().validators(latest_block, network).map_err(|_| {
+          jsonrpsee::core::Error::to_call_error(std::io::Error::other(format!(
+            "couldn't get validators from the latest block, which is likely a fatal bug. {}",
+            "please report this at https://github.com/serai-dex/serai",
+          )))
+        })?;
+        let mut all_p2p_addresses = vec![];
+        for validator in validators {
+          let mut returned_addresses = authority_discovery
+            .write()
+            .await
+            .get_addresses_by_authority_id(validator.into())
+            .await
+            .unwrap_or_else(HashSet::new)
+            .into_iter();
+          // Only take a single address
+          // There should be one, there may be two if their IP address changed, and more should only
+          // occur if they have multiple proxies/an IP address changing frequently/some issue
+          // preventing consistent self-identification
+          // It isn't beneficial to use multiple addresses for a single peer here
+          if let Some(address) = returned_addresses.next() {
+            all_p2p_addresses.push(address);
+          }
+        }
+        Ok(all_p2p_addresses)
+      },
+    )?;
+    module.merge(authority_discovery_module)?;
+  }
 
   Ok(module)
 }