fix: address comments

Author: m30m

apps/fortuna/src/api.rs

@@ -43,7 +43,7 @@ pub struct ApiMetrics {
 
 #[derive(Clone)]
 pub struct ApiState {
-    pub chains: Arc<RwLock<HashMap<ChainId, BlockchainState>>>,
+    pub chains: Arc<RwLock<HashMap<ChainId, ApiBlockChainState>>>,
 
     pub metrics_registry: Arc<RwLock<Registry>>,
 
@@ -53,7 +53,7 @@ pub struct ApiState {
 
 impl ApiState {
     pub async fn new(
-        chains: Arc<RwLock<HashMap<ChainId, BlockchainState>>>,
+        chains: Arc<RwLock<HashMap<ChainId, ApiBlockChainState>>>,
         metrics_registry: Arc<RwLock<Registry>>,
     ) -> ApiState {
         let metrics = ApiMetrics {
@@ -94,6 +94,12 @@ pub struct BlockchainState {
     pub confirmed_block_status: BlockStatus,
 }
 
+#[derive(Clone)]
+pub enum ApiBlockChainState {
+    Uninitialized,
+    Initialized(BlockchainState),
+}
+
 pub enum RestError {
     /// The caller passed a sequence number that isn't within the supported range
     InvalidSequenceNumber,
@@ -108,6 +114,9 @@ pub enum RestError {
     /// The server cannot currently communicate with the blockchain, so is not able to verify
     /// which random values have been requested.
     TemporarilyUnavailable,
+    /// The server is not able to process the request because the blockchain initialization
+    /// has not been completed yet.
+    Uninitialized,
     /// A catch-all error for all other types of errors that could occur during processing.
     Unknown,
 }
@@ -137,6 +146,11 @@ impl IntoResponse for RestError {
                 "This service is temporarily unavailable",
             )
                 .into_response(),
+            RestError::Uninitialized => (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "The service is not yet initialized for this chain, please try again in a few minutes",
+            )
+                .into_response(),
             RestError::Unknown => (
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "An unknown error occurred processing the request",
@@ -172,6 +186,7 @@ pub fn get_register_uri(base_uri: &str, chain_id: &str) -> Result<String> {
 
 #[cfg(test)]
 mod test {
+    use crate::api::ApiBlockChainState;
     use {
         crate::{
             api::{self, ApiState, BinaryEncoding, Blob, BlockchainState, GetRandomValueResponse},
@@ -228,8 +243,14 @@ mod test {
         };
 
         let mut chains = HashMap::new();
-        chains.insert("ethereum".into(), eth_state);
-        chains.insert("avalanche".into(), avax_state);
+        chains.insert(
+            "ethereum".into(),
+            ApiBlockChainState::Initialized(eth_state),
+        );
+        chains.insert(
+            "avalanche".into(),
+            ApiBlockChainState::Initialized(avax_state),
+        );
 
         let api_state = ApiState::new(Arc::new(RwLock::new(chains)), metrics_registry).await;
 

apps/fortuna/src/api/revelation.rs

@@ -1,3 +1,4 @@
+use crate::api::ApiBlockChainState;
 use crate::chain::reader::BlockNumber;
 use {
     crate::api::{ChainId, RequestLabel, RestError},
@@ -52,6 +53,13 @@ pub async fn revelation(
         .ok_or(RestError::InvalidChainId)?
         .clone();
 
+    let state = match state {
+        ApiBlockChainState::Initialized(state) => state,
+        ApiBlockChainState::Uninitialized => {
+            return Err(RestError::Uninitialized);
+        }
+    };
+
     let current_block_number_fut = state
         .contract
         .get_block_number(state.confirmed_block_status);

apps/fortuna/src/command/register_provider.rs

@@ -52,7 +52,7 @@ pub async fn register_provider_from_config(
 
     let commitment_length = provider_config.chain_length;
     tracing::info!("Generating hash chain");
-    let chain = PebbleHashChain::from_config(
+    let chain = PebbleHashChain::from_config_async(
         &secret,
         chain_id,
         &private_key_string.parse::<LocalWallet>()?.address(),

apps/fortuna/src/command/run.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        api::{self, BlockchainState, ChainId},
+        api::{self, ApiBlockChainState, BlockchainState, ChainId},
         chain::ethereum::InstrumentedPythContract,
         command::register_provider::CommitmentMetadata,
         config::{Commitment, Config, EthereumConfig, RunOptions},
@@ -24,7 +24,7 @@ use {
 
 pub async fn run_api(
     socket_addr: SocketAddr,
-    chains: Arc<RwLock<HashMap<String, api::BlockchainState>>>,
+    chains: Arc<RwLock<HashMap<String, ApiBlockChainState>>>,
     metrics_registry: Arc<RwLock<Registry>>,
     mut rx_exit: watch::Receiver<bool>,
 ) -> Result<()> {
@@ -91,7 +91,13 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
     if keeper_private_key_option.is_none() {
         tracing::info!("Not starting keeper service: no keeper private key specified. Please add one to the config if you would like to run the keeper service.")
     }
-    let chains: Arc<RwLock<HashMap<ChainId, BlockchainState>>> = Default::default();
+    let chains: Arc<RwLock<HashMap<ChainId, ApiBlockChainState>>> = Arc::new(RwLock::new(
+        config
+            .chains
+            .keys()
+            .map(|chain_id| (chain_id.clone(), ApiBlockChainState::Uninitialized))
+            .collect(),
+    ));
     for (chain_id, chain_config) in config.chains.clone() {
         let keeper_metrics = keeper_metrics.clone();
         let keeper_private_key_option = keeper_private_key_option.clone();
@@ -111,7 +117,10 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
             match state {
                 Ok(state) => {
                     keeper_metrics.add_chain(chain_id.clone(), state.provider_address);
-                    chains.write().await.insert(chain_id.clone(), state.clone());
+                    chains.write().await.insert(
+                        chain_id.clone(),
+                        ApiBlockChainState::Initialized(state.clone()),
+                    );
                     if let Some(keeper_private_key) = keeper_private_key_option {
                         spawn(keeper::run_keeper_threads(
                             keeper_private_key,
@@ -204,7 +213,7 @@ async fn setup_chain_state(
         let offset = commitment.original_commitment_sequence_number.try_into()?;
         offsets.push(offset);
 
-        let pebble_hash_chain = PebbleHashChain::from_config(
+        let pebble_hash_chain = PebbleHashChain::from_config_async(
             secret,
             chain_id,
             provider,

apps/fortuna/src/command/setup_provider.rs

@@ -112,7 +112,7 @@ async fn setup_chain_provider(
             );
             register = true;
         } else {
-            let hash_chain = PebbleHashChain::from_config(
+            let hash_chain = PebbleHashChain::from_config_async(
                 &secret,
                 chain_id,
                 &provider_address,

apps/fortuna/src/state.rs

@@ -43,24 +43,53 @@ impl PebbleHashChain {
         }
     }
 
-    pub async fn from_config(
+    fn generate_secret(
         secret: &str,
         chain_id: &ChainId,
         provider_address: &Address,
         contract_address: &Address,
         random: &[u8; 32],
-        chain_length: u64,
-        sample_interval: u64,
-    ) -> Result<Self> {
+    ) -> Result<[u8; 32]> {
         let mut input: Vec<u8> = vec![];
         input.extend_from_slice(&hex::decode(secret.trim())?);
         input.extend_from_slice(chain_id.as_bytes());
         input.extend_from_slice(provider_address.as_bytes());
         input.extend_from_slice(contract_address.as_bytes());
         input.extend_from_slice(random);
-
         let secret: [u8; 32] = Keccak256::digest(input).into();
+        Ok(secret)
+    }
 
+    pub fn from_config(
+        secret: &str,
+        chain_id: &ChainId,
+        provider_address: &Address,
+        contract_address: &Address,
+        random: &[u8; 32],
+        chain_length: u64,
+        sample_interval: u64,
+    ) -> Result<Self> {
+        let secret: [u8; 32] =
+            Self::generate_secret(secret, chain_id, provider_address, contract_address, random)?;
+        Ok(Self::new(
+            secret,
+            chain_length.try_into()?,
+            sample_interval.try_into()?,
+        ))
+    }
+
+    /// Asynchronous version of `from_config` that runs the computation in a blocking thread.
+    pub async fn from_config_async(
+        secret: &str,
+        chain_id: &ChainId,
+        provider_address: &Address,
+        contract_address: &Address,
+        random: &[u8; 32],
+        chain_length: u64,
+        sample_interval: u64,
+    ) -> Result<Self> {
+        let secret: [u8; 32] =
+            Self::generate_secret(secret, chain_id, provider_address, contract_address, random)?;
         let chain_length: usize = chain_length.try_into()?;
         let sample_interval: usize = sample_interval.try_into()?;
         let hash_chain = spawn_blocking(move || Self::new(secret, chain_length, sample_interval))