Add a faucet endpoint to return the current list of validators. (linera-io#1383)

afck · web-flow · commit 6d21bfbff79a · 2023-12-14T10:46:21.000+01:00
diff --git a/linera-core/src/node.rs b/linera-core/src/node.rs
@@ -82,13 +82,20 @@ pub trait ValidatorNodeProvider {
     where
         I: FromIterator<(ValidatorName, Self::Node)>,
     {
-        committee
-            .validators()
-            .iter()
-            .map(|(name, validator)| {
-                let node = self.make_node(&validator.network_address)?;
-                Ok((*name, node))
-            })
+        self.make_nodes_from_list(committee.validator_addresses())
+    }
+
+    fn make_nodes_from_list<I, A>(
+        &self,
+        validators: impl IntoIterator<Item = (ValidatorName, A)>,
+    ) -> Result<I, NodeError>
+    where
+        I: FromIterator<(ValidatorName, Self::Node)>,
+        A: AsRef<str>,
+    {
+        validators
+            .into_iter()
+            .map(|(name, address)| Ok((name, self.make_node(address.as_ref())?)))
             .collect()
     }
 }
diff --git a/linera-execution/src/committee.rs b/linera-execution/src/committee.rs
@@ -350,6 +350,12 @@ impl Committee {
         &self.validators
     }
 
+    pub fn validator_addresses(&self) -> impl Iterator<Item = (ValidatorName, &str)> {
+        self.validators
+            .iter()
+            .map(|(name, validator)| (*name, &*validator.network_address))
+    }
+
     pub fn total_votes(&self) -> u64 {
         self.total_votes
     }
diff --git a/linera-service/src/cli_wrappers/wallet.rs b/linera-service/src/cli_wrappers/wallet.rs
@@ -16,7 +16,7 @@ use linera_base::{
     data_types::Amount,
     identifiers::{ApplicationId, BytecodeId, ChainId, MessageId, Owner},
 };
-use linera_execution::Bytecode;
+use linera_execution::{committee::ValidatorName, Bytecode};
 use serde::{de::DeserializeOwned, ser::Serialize};
 use serde_json::{json, Value};
 use std::{
@@ -888,6 +888,46 @@ impl Faucet {
         };
         Ok(outcome)
     }
+
+    pub async fn current_validators(url: &str) -> Result<Vec<(ValidatorName, String)>> {
+        let query = "query { currentValidators { name networkAddress } }";
+        let client = reqwest_client();
+        let response = client
+            .post(url)
+            .json(&json!({ "query": query }))
+            .send()
+            .await
+            .context("failed to post query")?;
+        anyhow::ensure!(
+            response.status().is_success(),
+            "Query \"{}\" failed: {}",
+            query,
+            response
+                .text()
+                .await
+                .unwrap_or_else(|error| format!("Could not get response text: {error}"))
+        );
+        let mut value: Value = response.json().await.context("invalid JSON")?;
+        if let Some(errors) = value.get("errors") {
+            bail!("Query \"{}\" failed: {}", query, errors);
+        }
+        let validators = match value["data"]["currentValidators"].take() {
+            serde_json::Value::Array(validators) => validators,
+            validators => bail!("{validators} is not an array"),
+        };
+        validators
+            .into_iter()
+            .map(|mut validator| {
+                let name = serde_json::from_value::<ValidatorName>(validator["name"].take())
+                    .context("could not parse current validators: invalid name")?;
+                let addr = validator["networkAddress"]
+                    .as_str()
+                    .context("could not parse current validators: invalid address")?
+                    .to_string();
+                Ok((name, addr))
+            })
+            .collect()
+    }
 }
 
 /// A running `Application` to be queried in GraphQL.
diff --git a/linera-service/src/faucet.rs b/linera-service/src/faucet.rs
@@ -14,9 +14,10 @@ use linera_core::{
     client::{ChainClient, ChainClientError},
     node::ValidatorNodeProvider,
 };
-use linera_execution::ChainOwnership;
+use linera_execution::{committee::ValidatorName, ChainOwnership};
 use linera_storage::Storage;
 use linera_views::views::ViewError;
+use serde::Deserialize;
 use serde_json::json;
 use std::{net::SocketAddr, num::NonZeroU16, sync::Arc};
 use thiserror::Error as ThisError;
@@ -30,8 +31,9 @@ use crate::{config::GenesisConfig, util};
 mod tests;
 
 /// The root GraphQL query type.
-pub struct QueryRoot {
+pub struct QueryRoot<P, S> {
     genesis_config: Arc<GenesisConfig>,
+    client: Arc<Mutex<ChainClient<P, S>>>,
 }
 
 /// The root GraphQL mutation type.
@@ -66,12 +68,37 @@ pub struct ClaimOutcome {
     pub certificate_hash: CryptoHash,
 }
 
+#[derive(Debug, Deserialize, SimpleObject)]
+pub struct Validator {
+    pub name: ValidatorName,
+    pub network_address: String,
+}
+
 #[Object]
-impl QueryRoot {
+impl<P, S> QueryRoot<P, S>
+where
+    P: ValidatorNodeProvider + Send + Sync + 'static,
+    S: Storage + Clone + Send + Sync + 'static,
+    ViewError: From<S::ContextError>,
+{
     /// Returns the genesis config.
     async fn genesis_config(&self) -> Result<serde_json::Value, Error> {
         Ok(serde_json::to_value(&*self.genesis_config)?)
     }
+
+    /// Returns the current committee's validators.
+    async fn current_validators(&self) -> Result<Vec<Validator>, Error> {
+        let mut client = self.client.lock().await;
+        let committee = client.local_committee().await?;
+        Ok(committee
+            .validators()
+            .iter()
+            .map(|(name, validator)| Validator {
+                name: *name,
+                network_address: validator.network_address.clone(),
+            })
+            .collect())
+    }
 }
 
 #[Object]
@@ -181,7 +208,7 @@ where
         })
     }
 
-    pub fn schema(&self) -> Schema<QueryRoot, MutationRoot<P, S>, EmptySubscription> {
+    pub fn schema(&self) -> Schema<QueryRoot<P, S>, MutationRoot<P, S>, EmptySubscription> {
         let mutation_root = MutationRoot {
             client: self.client.clone(),
             amount: self.amount,
@@ -191,6 +218,7 @@ where
         };
         let query_root = QueryRoot {
             genesis_config: self.genesis_config.clone(),
+            client: self.client.clone(),
         };
         Schema::build(query_root, mutation_root, EmptySubscription).finish()
     }
diff --git a/linera-service/src/linera.rs b/linera-service/src/linera.rs
@@ -1811,8 +1811,15 @@ impl Runnable for Job {
 
             Assign { key, message_id } => {
                 let chain_id = ChainId::child(message_id);
-                Self::assign_new_chain_to_key(chain_id, message_id, storage, key, &mut context)
-                    .await?;
+                Self::assign_new_chain_to_key(
+                    chain_id,
+                    message_id,
+                    storage,
+                    key,
+                    None,
+                    &mut context,
+                )
+                .await?;
                 println!("{}", chain_id);
                 context.save_wallet();
             }
@@ -1885,6 +1892,7 @@ impl Runnable for Job {
                 let public_key = key_pair.public();
                 context.wallet_state.add_unassigned_key_pair(key_pair);
                 let outcome = cli_wrappers::Faucet::claim_url(&public_key, &faucet_url).await?;
+                let validators = cli_wrappers::Faucet::current_validators(&faucet_url).await?;
                 println!("{}", outcome.chain_id);
                 println!("{}", outcome.message_id);
                 println!("{}", outcome.certificate_hash);
@@ -1893,6 +1901,7 @@ impl Runnable for Job {
                     outcome.message_id,
                     storage.clone(),
                     public_key,
+                    Some(validators),
                     &mut context,
                 )
                 .await?;
@@ -1919,6 +1928,7 @@ impl Job {
         message_id: MessageId,
         storage: S,
         public_key: PublicKey,
+        validators: Option<Vec<(ValidatorName, String)>>,
         context: &mut ClientContext,
     ) -> anyhow::Result<()>
     where
@@ -1933,11 +1943,17 @@ impl Job {
         // Take the latest committee we know of.
         let admin_chain_id = context.wallet_state.genesis_admin_chain();
         let query = ChainInfoQuery::new(admin_chain_id).with_committees();
-        let info = node_client.handle_chain_info_query(query).await?;
-        let committee = info
-            .latest_committee()
-            .context("Invalid chain info response; missing latest committee")?;
-        let nodes = context.make_node_provider().make_nodes(committee)?;
+        let nodes = if let Some(validators) = validators {
+            context
+                .make_node_provider()
+                .make_nodes_from_list(validators)?
+        } else {
+            let info = node_client.handle_chain_info_query(query).await?;
+            let committee = info
+                .latest_committee()
+                .context("Invalid chain info response; missing latest committee")?;
+            context.make_node_provider().make_nodes(committee)?
+        };
 
         // Download the parent chain.
         let target_height = message_id.height.try_add_one()?;

Original file line number	Diff line number	Diff line change
`@@ -350,6 +350,12 @@ impl Committee {`
`350`	`350`	`&self.validators`
`351`	`351`	`}`
`352`	`352`
	`353`	`+ pub fn validator_addresses(&self) -> impl Iterator<Item = (ValidatorName, &str)> {`
	`354`	`+ self.validators`
	`355`	`+ .iter()`
	`356`	`+ .map(\|(name, validator)\| (name, &validator.network_address))`
	`357`	`+ }`
	`358`	`+`
`353`	`359`	`pub fn total_votes(&self) -> u64 {`
`354`	`360`	`self.total_votes`
`355`	`361`	`}`