CLI for testing

Author: jayantk

apps/fortuna/src/chain/ethereum.rs

@@ -93,6 +93,38 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
         }
     }
 
+    /// Submit a request for a random number to the contract.
+    ///
+    /// This method is a version of the autogenned `request` method that parses the emitted logs
+    /// to return the sequence number of the created Request.
+    pub async fn request_with_callback_wrapper(
+        &self,
+        provider: &Address,
+        user_randomness: &[u8; 32],
+    ) -> Result<u64> {
+        let fee = self.get_fee(*provider).call().await?;
+
+        let hashed_randomness: [u8; 32] = Keccak256::digest(user_randomness).into();
+
+        if let Some(r) = self
+            .request_with_callback(*provider, hashed_randomness)
+            .value(fee)
+            .send()
+            .await?
+            .await?
+        {
+            // Extract Log from TransactionReceipt.
+            let l: RawLog = r.logs[0].clone().into();
+            if let PythRandomEvents::RequestedFilter(r) = PythRandomEvents::decode_log(&l)? {
+                Ok(r.request.sequence_number)
+            } else {
+                Err(anyhow!("No log with sequence number"))
+            }
+        } else {
+            Err(anyhow!("Request failed"))
+        }
+    }
+
     /// Reveal the generated random number to the contract.
     ///
     /// This method is a version of the autogenned `reveal` method that parses the emitted logs

apps/fortuna/src/command/generate.rs

@@ -1,12 +1,9 @@
 use {
     crate::{
-        api::GetRandomValueResponse,
-        chain::ethereum::SignablePythContract,
+        chain::ethereum::{SignablePythContract, RevealedWithCallbackFilter},
         config::{Config, GenerateOptions},
-    },
-    anyhow::Result,
-    base64::{engine::general_purpose::STANDARD as base64_standard_engine, Engine as _},
-    std::sync::Arc,
+    }, anyhow::Result, base64::{engine::general_purpose::STANDARD as base64_standard_engine, Engine as _}, ethers::providers::Middleware, std::sync::Arc,
+    tokio::time::{self, Duration},
 };
 
 /// Run the entire random number generation protocol to produce a random number.
@@ -22,42 +19,41 @@ pub async fn generate(opts: &GenerateOptions) -> Result<()> {
     let user_randomness = rand::random::<[u8; 32]>();
     let provider = opts.provider;
 
+    let mut last_block_number = contract.provider().get_block_number().await?;
+
     // Request a random number on the contract
     let sequence_number = contract
-        .request_wrapper(&provider, &user_randomness, opts.blockhash)
+        .request_with_callback_wrapper(&provider, &user_randomness)
         .await?;
 
     tracing::info!(sequence_number = sequence_number, "random number requested",);
 
-    // Get the committed value from the provider
-    let resp = reqwest::get(opts.url.join(&format!(
-        "/v1/chains/{}/revelations/{}",
-        opts.chain_id, sequence_number
-    ))?)
-    .await?
-    .json::<GetRandomValueResponse>()
-    .await?;
-
-    tracing::info!(
-        response = base64_standard_engine.encode(resp.value.data()),
-        "Retrieved the provider's random value.",
-    );
-    let provider_randomness = resp.value.data();
-
-    // Submit the provider's and our values to the contract to reveal the random number.
-    let random_value = contract
-        .reveal_wrapper(
-            &provider,
-            sequence_number,
-            &user_randomness,
-            provider_randomness,
-        )
-        .await?;
-
-    tracing::info!(
-        number = base64_standard_engine.encode(random_value),
-        "Random number generated."
-    );
+    for _i in [0..10] {
+        let current_block_number = contract.provider().get_block_number().await?;
+        tracing::info!(
+            start_block = last_block_number.as_u64(),
+            end_block = current_block_number.as_u64(),
+            "Checking events between blocks."
+        );
+
+        let mut event = contract.revealed_with_callback_filter();
+        event.filter = event.filter.from_block(last_block_number).to_block(current_block_number);
+
+        let res: Vec<RevealedWithCallbackFilter> = event.query().await?;
+
+        for r in res.iter() {
+            if r.request.sequence_number == sequence_number && r.request.provider == provider {
+                tracing::info!(
+                    number = base64_standard_engine.encode(r.random_number),
+                    "Random number generated."
+                );
+                break;
+            }
+        }
+
+        last_block_number = current_block_number;
+        time::sleep(Duration::from_secs(1)).await;
+    }
 
     Ok(())
 }

apps/fortuna/src/config.rs

@@ -25,7 +25,6 @@ mod setup_provider;
 mod withdraw_fees;
 
 const DEFAULT_RPC_ADDR: &str = "127.0.0.1:34000";
-const DEFAULT_HTTP_ADDR: &str = "http://127.0.0.1:34000";
 
 #[derive(Parser, Debug)]
 #[command(name = crate_name!())]

apps/fortuna/src/config/generate.rs

@@ -2,7 +2,6 @@ use {
     crate::{api::ChainId, config::ConfigOptions},
     clap::Args,
     ethers::types::Address,
-    reqwest::Url,
 };
 
 #[derive(Args, Clone, Debug)]
@@ -27,11 +26,4 @@ pub struct GenerateOptions {
     /// Submit a randomness request to this provider
     #[arg(long = "provider")]
     pub provider: Address,
-
-    #[arg(long = "url")]
-    #[arg(default_value = super::DEFAULT_HTTP_ADDR)]
-    pub url: Url,
-
-    #[arg(short = 'b')]
-    pub blockhash: bool,
 }