fix(entropy): Use the block number of event instead of request data for revelation api

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: bigint,
   sequenceNumber: number,
 ) {
   const deployment = EntropyDeployments[chain];
   const url = new URL(
-    `/v1/chains/${chain}/revelations/${sequenceNumber.toString()}`,
+    `/v1/chains/${chain}/revelations/${sequenceNumber.toString()}?block_number=${blockNumber.toString()}`,
     deployment.network === "mainnet"
       ? "https://fortuna.dourolabs.app"
       : "https://fortuna-staging.dourolabs.app",

apps/fortuna/Cargo.toml

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

apps/fortuna/src/api/revelation.rs

@@ -1,3 +1,4 @@
+use crate::chain::reader::BlockNumber;
 use {
     crate::api::{ChainId, RequestLabel, RestError},
     anyhow::Result,
@@ -30,7 +31,10 @@ params(RevelationPathParams, RevelationQueryParams)
 pub async fn revelation(
     State(state): State<crate::api::ApiState>,
     Path(RevelationPathParams { chain_id, sequence }): Path<RevelationPathParams>,
-    Query(RevelationQueryParams { encoding }): Query<RevelationQueryParams>,
+    Query(RevelationQueryParams {
+        encoding,
+        block_number,
+    }): Query<RevelationQueryParams>,
 ) -> Result<Json<GetRandomValueResponse>, RestError> {
     state
         .metrics
@@ -45,40 +49,68 @@ pub async fn revelation(
         .get(&chain_id)
         .ok_or(RestError::InvalidChainId)?;
 
-    let maybe_request_fut = state.contract.get_request(state.provider_address, sequence);
-
     let current_block_number_fut = state
         .contract
         .get_block_number(state.confirmed_block_status);
 
-    let (maybe_request, current_block_number) =
-        try_join!(maybe_request_fut, current_block_number_fut).map_err(|e| {
-            tracing::error!(chain_id = chain_id, "RPC request failed {}", e);
-            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,
-            }))
+    match block_number {
+        Some(block_number) => {
+            let maybe_request_fut = state.contract.get_request_with_callback_events(
+                block_number,
+                block_number,
+                state.provider_address,
+            );
+
+            let (maybe_request, current_block_number) =
+                try_join!(maybe_request_fut, current_block_number_fut).map_err(|e| {
+                    tracing::error!(chain_id = chain_id, "RPC request failed {}", e);
+                    RestError::TemporarilyUnavailable
+                })?;
+
+            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)?;
+        }
+        None => {
+            let maybe_request_fut = state.contract.get_request(state.provider_address, sequence);
+            let (maybe_request, current_block_number) =
+                try_join!(maybe_request_fut, current_block_number_fut).map_err(|e| {
+                    tracing::error!(chain_id = chain_id, "RPC request failed {}", e);
+                    RestError::TemporarilyUnavailable
+                })?;
+
+            match maybe_request {
+                Some(r)
+                    if current_block_number.saturating_sub(state.reveal_delay_blocks)
+                        >= r.block_number =>
+                {
+                    Ok(())
+                }
+                Some(_) => Err(RestError::PendingConfirmation),
+                None => Err(RestError::NoPendingRequest),
+            }?;
         }
-        Some(_) => Err(RestError::PendingConfirmation),
-        None => Err(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)]
@@ -93,6 +125,8 @@ pub struct RevelationPathParams {
 #[into_params(parameter_in=Query)]
 pub struct RevelationQueryParams {
     pub encoding: Option<BinaryEncoding>,
+    #[param(value_type = u64)]
+    pub block_number: Option<BlockNumber>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, ToSchema)]

apps/fortuna/src/chain/ethereum.rs

@@ -276,9 +276,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?;
 
@@ -289,6 +294,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/reader.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/keeper/block.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 {