it works

pyth-rng/src/api.rs

@@ -7,6 +7,7 @@ use axum::{
         Response,
     },
 };
+use ethers::core::types::Address;
 
 pub use {
     get_randomness_proof::*,
@@ -14,7 +15,6 @@ pub use {
 
 use crate::ethereum::PythProvider;
 use crate::ethereum::provider;
-
 use crate::PebbleHashChain;
 
 mod get_randomness_proof;
@@ -22,8 +22,8 @@ mod get_randomness_proof;
 #[derive(Clone)]
 pub struct ApiState {
     pub state: Arc<PebbleHashChain>,
-    pub provider: Arc<PythProvider>,
-    pub provider_addr: Address,
+    pub contract: Arc<PythProvider>,
+    pub provider: Address,
 }
 
 // FIXME: real errors

pyth-rng/src/api/get_randomness_proof.rs

@@ -41,10 +41,19 @@ pub async fn get_random_value(
     State(state): State<crate::api::ApiState>,
     QsQuery(params): QsQuery<GetRandomValueQueryParams>,
 ) -> Result<Json<GetRandomValueResponse>, RestError> {
-    // TODO: check on-chain sequence number here
-    let value = &state.state.reveal_ith(params.sequence.try_into().map_err(|_| RestError::TestError)?).map_err(|_| RestError::TestError)?;
+    let sequence: u64 = params.sequence.try_into().map_err(|_| RestError::TestError)?;
+    let sequence_usize: usize = sequence.try_into().map_err(|_| RestError::TestError)?;
 
-    Ok(Json(GetRandomValueResponse { value: (*value).clone() } ))
+    let r = state.contract.get_request(state.provider, sequence).call().await.map_err(|_| RestError::TestError)?;
+
+    if r.sequence_number != 0 {
+        println!("Found request: {:?}", r);
+        let value = &state.state.reveal_ith(sequence_usize).map_err(|_| RestError::TestError)?;
+        Ok(Json(GetRandomValueResponse { value: (*value).clone() }))
+    } else {
+        println!("No request for sequence number: {:?}", sequence);
+        Err(RestError::TestError)
+    }
 }
 
 #[derive(Debug, serde::Deserialize, IntoParams)]

pyth-rng/src/config/run.rs

@@ -17,4 +17,10 @@ pub struct RunOptions {
     #[arg(default_value = DEFAULT_RPC_ADDR)]
     #[arg(env = "RPC_ADDR")]
     pub addr: SocketAddr,
+
+    /// The public key of the provider whose requests the server will respond to.
+    #[arg(long = "provider")]
+    #[arg(env = "PYTH_PROVIDER")]
+    #[arg(default_value = "0x368397bDc956b4F23847bE244f350Bde4615F25E")]
+    pub provider: String,
 }

pyth-rng/src/main.rs

@@ -29,6 +29,7 @@ use {
 use ethereum::register_provider;
 use ethereum::request_randomness;
 use ethereum::get_request;
+use ethers::core::types::Address;
 
 use crate::api::{ApiState, get_random_value};
 use crate::state::PebbleHashChain;
@@ -71,8 +72,8 @@ async fn run(opts: &RunOptions) -> Result<(), Box<dyn Error>> {
     let random = [0u8; 32]; // rand::random::<[u8; 32]>();
     let mut chain = PebbleHashChain::from_config(&opts.randomness, random)?;
     let contract = Arc::new(provider(&opts.ethereum).await?);
-    let provider = opts.provider_address.parse::<Address>()?;
-    let mut state = ApiState{ state: Arc::new(chain), provider: contract, provider_address: provider};
+    let provider_addr = opts.provider.parse::<Address>()?;
+    let mut state = ApiState{ state: Arc::new(chain), contract, provider: provider_addr };
 
     // Initialize Axum Router. Note the type here is a `Router<State>` due to the use of the
     // `with_state` method which replaces `Body` with `State` in the type signature.
@@ -84,6 +85,8 @@ async fn run(opts: &RunOptions) -> Result<(), Box<dyn Error>> {
         // Permissive CORS layer to allow all origins
         .layer(CorsLayer::permissive());
 
+
+    println!("Starting server on: {:?}", &opts.addr);
     // Binds the axum's server to the configured address and port. This is a blocking call and will
     // not return until the server is shutdown.
     axum::Server::try_bind(&opts.addr)?