Use the block number of event instead of request data for revelation api

Author: m30m

apps/entropy-debugger/src/lib/revelation.ts

@@ -10,11 +10,13 @@ export async function requestCallback(
   chain: keyof typeof EntropyDeployments,
 ): Promise<string> {
   const deployment = EntropyDeployments[chain];
-  const { provider, sequenceNumber, userRandomNumber } = await fetchInfoFromTx(
-    txHash,
-    deployment,
+  const { provider, sequenceNumber, userRandomNumber, blockNumber } =
+    await fetchInfoFromTx(txHash, deployment);
+  const revelation = await getRevelation(
+    chain,
+    blockNumber,
+    Number(sequenceNumber),
   );
-  const revelation = await getRevelation(chain, Number(sequenceNumber));
 
   return `cast send ${deployment.address} 'revealWithCallback(address, uint64, bytes32, bytes32)' ${provider} ${sequenceNumber.toString()} ${userRandomNumber} ${revelation.value.data} -r ${deployment.rpc} --private-key <YOUR_PRIVATE_KEY>`;
 }
@@ -40,7 +42,12 @@ export async function fetchInfoFromTx(
   const firstLog = logs[0];
   if (firstLog) {
     const { provider, sequenceNumber, userRandomNumber } = firstLog.args;
-    return { provider, sequenceNumber, userRandomNumber };
+    return {
+      provider,
+      sequenceNumber,
+      userRandomNumber,
+      blockNumber: receipt.blockNumber,
+    };
   } else {
     throw new Error(
       `No logs found for ${txHash}. Are you sure you send the requestCallback Transaction?`,
@@ -50,11 +57,12 @@ export async function fetchInfoFromTx(
 
 export async function getRevelation(
   chain: keyof typeof EntropyDeployments,
+  blockNumber: number,
   sequenceNumber: number,
 ) {
   const deployment = EntropyDeployments[chain];
   const url = new URL(
-    `/v1/chains/${chain}/revelations/${sequenceNumber.toString()}`,
+    `/v1/chains/${chain}/revelations/${blockNumber.toString()}/${sequenceNumber.toString()}`,
     deployment.network === "mainnet"
       ? "https://fortuna.dourolabs.app"
       : "https://fortuna-staging.dourolabs.app",

apps/fortuna/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "7.4.10"
+version = "7.5.0"
 edition = "2021"
 
 [lib]

apps/fortuna/Cargo.toml

@@ -154,7 +154,7 @@ pub fn routes(state: ApiState) -> Router<(), Body> {
         .route("/ready", get(ready))
         .route("/v1/chains", get(chain_ids))
         .route(
-            "/v1/chains/:chain_id/revelations/:sequence",
+            "/v1/chains/:chain_id/revelations/:block_number/:sequence",
             get(revelation),
         )
         .with_state(state)

apps/fortuna/src/api.rs

@@ -1,3 +1,4 @@
+use crate::chain::reader::BlockNumber;
 use {
     crate::api::{ChainId, RequestLabel, RestError},
     anyhow::Result,
@@ -20,7 +21,7 @@ use {
 /// Callers must pass the appropriate chain_id to ensure they fetch the correct random number.
 #[utoipa::path(
 get,
-path = "/v1/chains/{chain_id}/revelations/{sequence}",
+path = "/v1/chains/{chain_id}/revelations/{block_number}/{sequence}",
 responses(
 (status = 200, description = "Random value successfully retrieved", body = GetRandomValueResponse),
 (status = 403, description = "Random value cannot currently be retrieved", body = String)
@@ -29,7 +30,11 @@ params(RevelationPathParams, RevelationQueryParams)
 )]
 pub async fn revelation(
     State(state): State<crate::api::ApiState>,
-    Path(RevelationPathParams { chain_id, sequence }): Path<RevelationPathParams>,
+    Path(RevelationPathParams {
+        chain_id,
+        sequence,
+        block_number,
+    }): Path<RevelationPathParams>,
     Query(RevelationQueryParams { encoding }): Query<RevelationQueryParams>,
 ) -> Result<Json<GetRandomValueResponse>, RestError> {
     state
@@ -45,7 +50,11 @@ pub async fn revelation(
         .get(&chain_id)
         .ok_or(RestError::InvalidChainId)?;
 
-    let maybe_request_fut = state.contract.get_request(state.provider_address, sequence);
+    let maybe_request_fut = state.contract.get_request_with_callback_events(
+        block_number,
+        block_number,
+        state.provider_address,
+    );
 
     let current_block_number_fut = state
         .contract
@@ -57,28 +66,29 @@ pub async fn revelation(
             RestError::TemporarilyUnavailable
         })?;
 
-    match maybe_request {
-        Some(r)
-            if current_block_number.saturating_sub(state.reveal_delay_blocks) >= r.block_number =>
-        {
-            let value = &state.state.reveal(sequence).map_err(|e| {
-                tracing::error!(
-                    chain_id = chain_id,
-                    sequence = sequence,
-                    "Reveal failed {}",
-                    e
-                );
-                RestError::Unknown
-            })?;
-            let encoded_value = Blob::new(encoding.unwrap_or(BinaryEncoding::Hex), *value);
-
-            Ok(Json(GetRandomValueResponse {
-                value: encoded_value,
-            }))
-        }
-        Some(_) => Err(RestError::PendingConfirmation),
-        None => Err(RestError::NoPendingRequest),
+    if current_block_number.saturating_sub(state.reveal_delay_blocks) < block_number {
+        return Err(RestError::PendingConfirmation);
     }
+
+    maybe_request
+        .iter()
+        .find(|r| r.sequence_number == sequence)
+        .ok_or(RestError::NoPendingRequest)?;
+
+    let value = &state.state.reveal(sequence).map_err(|e| {
+        tracing::error!(
+            chain_id = chain_id,
+            sequence = sequence,
+            "Reveal failed {}",
+            e
+        );
+        RestError::Unknown
+    })?;
+    let encoded_value = Blob::new(encoding.unwrap_or(BinaryEncoding::Hex), *value);
+
+    Ok(Json(GetRandomValueResponse {
+        value: encoded_value,
+    }))
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, IntoParams)]
@@ -87,6 +97,8 @@ pub struct RevelationPathParams {
     #[param(value_type = String)]
     pub chain_id: ChainId,
     pub sequence: u64,
+    #[param(value_type = u64)]
+    pub block_number: BlockNumber,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, IntoParams)]

apps/fortuna/src/api/revelation.rs

@@ -244,9 +244,14 @@ impl<T: JsonRpcClient + 'static> EntropyReader for PythRandom<Provider<T>> {
         &self,
         from_block: BlockNumber,
         to_block: BlockNumber,
+        provider: Address,
     ) -> Result<Vec<RequestedWithCallbackEvent>> {
         let mut event = self.requested_with_callback_filter();
-        event.filter = event.filter.from_block(from_block).to_block(to_block);
+        event.filter = event
+            .filter
+            .from_block(from_block)
+            .to_block(to_block)
+            .topic1(provider);
 
         let res: Vec<RequestedWithCallbackFilter> = event.query().await?;
 
@@ -257,6 +262,7 @@ impl<T: JsonRpcClient + 'static> EntropyReader for PythRandom<Provider<T>> {
                 user_random_number: r.user_random_number,
                 provider_address: r.request.provider,
             })
+            .filter(|r| r.provider_address == provider)
             .collect())
     }
 

apps/fortuna/src/chain/ethereum.rs

@@ -51,6 +51,7 @@ pub trait EntropyReader: Send + Sync {
         &self,
         from_block: BlockNumber,
         to_block: BlockNumber,
+        provider: Address,
     ) -> Result<Vec<RequestedWithCallbackEvent>>;
 
     /// Estimate the gas required to reveal a random number with a callback.
@@ -166,6 +167,7 @@ pub mod mock {
             &self,
             _from_block: BlockNumber,
             _to_block: BlockNumber,
+            _provider: Address,
         ) -> Result<Vec<super::RequestedWithCallbackEvent>> {
             Ok(vec![])
         }

apps/fortuna/src/chain/reader.rs

@@ -122,7 +122,11 @@ pub async fn process_single_block_batch(
     loop {
         let events_res = chain_state
             .contract
-            .get_request_with_callback_events(block_range.from, block_range.to)
+            .get_request_with_callback_events(
+                block_range.from,
+                block_range.to,
+                chain_state.provider_address,
+            )
             .await;
 
         match events_res {