fix(fortuna): confirm reveal via on-chain event for already-revealed requests

When a reveal errors after retries but the request is gone from contract
storage, confirm a reveal actually happened by querying the on-chain v2
Revealed event for (provider, sequence) before recording a terminal state:
record Completed if found, otherwise leave Pending. This is reorg-safe --
get_request_v2 == None is ambiguous (revealed vs reorged out), so we no
longer infer a reveal from absence.

Reverts the earlier Resolved-state approach (and its entropy-explorer
changes) in this PR; recording the existing Completed state needs no
explorer change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: aditya520

Cargo.lock

@@ -136,7 +136,6 @@ const useStatusSelect = () => {
             { id: Status.Pending },
             { id: Status.Failed },
             { id: Status.CallbackError },
-            { id: Status.Resolved },
           ],
         },
       ],
@@ -169,9 +168,6 @@ const parseStatus = (value: string) => {
     case StatusParams[Status.Failed]: {
       return Status.Failed;
     }
-    case StatusParams[Status.Resolved]: {
-      return Status.Resolved;
-    }
     default: {
       return "all";
     }

apps/entropy-explorer/src/components/Home/search-controls.tsx

@@ -37,12 +37,5 @@ export const Status = ({ status, ...props }: Props) => {
         </StatusImpl>
       );
     }
-    case StatusType.Resolved: {
-      return (
-        <StatusImpl variant="info" {...props}>
-          REVEALED
-        </StatusImpl>
-      );
-    }
   }
 };

apps/entropy-explorer/src/components/Status/index.tsx

@@ -94,13 +94,6 @@ export const getRequests = async ({
                   case "pending": {
                     return Request.Pending(common);
                   }
-                  case "resolved": {
-                    return Request.Resolved({
-                      ...common,
-                      providerContribution:
-                        request.state.provider_random_number,
-                    });
-                  }
                   case "failed": {
                     return Request.Failed({
                       ...common,
@@ -201,11 +194,6 @@ const failedSchema = z.strictObject({
   state: z.literal("failed"),
 });
 
-const resolvedSchema = z.strictObject({
-  provider_random_number: z.string(),
-  state: z.literal("resolved"),
-});
-
 const fortunaSchema = z.strictObject({
   requests: z.array(
     z.strictObject({
@@ -219,12 +207,7 @@ const fortunaSchema = z.strictObject({
       request_tx_hash: hexStringSchema,
       sender: hexStringSchema,
       sequence: z.number(),
-      state: z.union([
-        completedStateSchema,
-        pendingStateSchema,
-        failedSchema,
-        resolvedSchema,
-      ]),
+      state: z.union([completedStateSchema, pendingStateSchema, failedSchema]),
       user_random_number: z.string(),
     }),
   ),
@@ -236,7 +219,6 @@ export enum Status {
   Failed,
   CallbackError,
   Complete,
-  Resolved,
 }
 
 type BaseArgs = {
@@ -264,9 +246,6 @@ type CompletedArgs = BaseArgs & {
 type CallbackErrorArgs = CompletedArgs & {
   reason: string;
 };
-type ResolvedArgs = BaseArgs & {
-  providerContribution: string;
-};
 
 const Request = {
   CallbackErrored: (args: CallbackErrorArgs) => ({
@@ -285,24 +264,18 @@ const Request = {
     status: Status.Pending as const,
     ...args,
   }),
-  Resolved: (args: ResolvedArgs) => ({
-    status: Status.Resolved as const,
-    ...args,
-  }),
 };
 export type Request = ReturnType<(typeof Request)[keyof typeof Request]>;
 export type PendingRequest = ReturnType<typeof Request.Pending>;
 export type FailedRequest = ReturnType<typeof Request.Failed>;
 export type CallbackErrorRequest = ReturnType<typeof Request.CallbackErrored>;
 export type CompleteRequest = ReturnType<typeof Request.Complete>;
-export type ResolvedRequest = ReturnType<typeof Request.Resolved>;
 
 export const StatusParams = {
   [Status.Pending]: "pending",
   [Status.Failed]: "failed",
   [Status.Complete]: "complete",
   [Status.CallbackError]: "callback-error",
-  [Status.Resolved]: "resolved",
 } as const;
 
 const toFortunaStatus = (status: string) => {
@@ -319,9 +292,6 @@ const toFortunaStatus = (status: string) => {
     case StatusParams[Status.CallbackError]: {
       return "CallbackErrored";
     }
-    case StatusParams[Status.Resolved]: {
-      return "Resolved";
-    }
     default: {
       return;
     }

apps/entropy-explorer/src/requests.ts

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

apps/fortuna/Cargo.toml

@@ -45,7 +45,6 @@ pub enum StateTag {
     Failed,
     Completed,
     CallbackErrored,
-    Resolved,
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, EncodeLabelSet)]

apps/fortuna/src/api.rs

@@ -3,7 +3,9 @@
 use {
     crate::{
         api::ChainId,
-        chain::reader::{self, BlockNumber, BlockStatus, EntropyReader, RequestedV2Event},
+        chain::reader::{
+            self, BlockNumber, BlockStatus, EntropyReader, RequestedV2Event, RevealedV2Event,
+        },
         config::EthereumConfig,
         eth_utils::{
             eth_gas_oracle::EthProviderOracle,
@@ -22,7 +24,7 @@ use {
         prelude::JsonRpcClient,
         providers::{Http, Middleware, Provider},
         signers::{LocalWallet, Signer},
-        types::{BlockNumber as EthersBlockNumber, U256},
+        types::{BlockNumber as EthersBlockNumber, H256, U256},
     },
     sha3::{Digest, Keccak256},
     std::sync::Arc,
@@ -339,6 +341,49 @@ impl<T: JsonRpcClient + 'static> EntropyReader for PythRandom<Provider<T>> {
             .collect())
     }
 
+    async fn get_revealed_event(
+        &self,
+        provider: Address,
+        sequence_number: u64,
+        from_block: BlockNumber,
+    ) -> Result<Option<RevealedV2Event>> {
+        let mut event = self.revealed_2_filter();
+        // provider and sequence_number are indexed (topic1, topic3), so filter server-side to this
+        // single request rather than scanning the whole block range.
+        event.filter = event
+            .filter
+            .address(self.address())
+            .from_block(from_block)
+            .topic1(provider)
+            .topic3(H256::from_low_u64_be(sequence_number));
+
+        let res: Vec<(Revealed2Filter, LogMeta)> = event.query_with_meta().await?;
+        // The callback-failed branch emits a Revealed event without clearing the request, so only a
+        // `callback_failed == false` event is a clearing reveal.
+        let Some((revealed, log_meta)) = res.into_iter().find(|(r, _)| !r.callback_failed) else {
+            return Ok(None);
+        };
+
+        let gas_used = self
+            .client()
+            .get_transaction_receipt(log_meta.transaction_hash)
+            .await
+            .ok()
+            .flatten()
+            .and_then(|receipt| receipt.gas_used)
+            .unwrap_or_default();
+
+        Ok(Some(RevealedV2Event {
+            provider_revelation: revealed.provider_contribution,
+            random_number: revealed.random_number,
+            callback_failed: revealed.callback_failed,
+            callback_return_value: revealed.callback_return_value,
+            callback_gas_used: revealed.callback_gas_used,
+            gas_used,
+            log_meta,
+        }))
+    }
+
     async fn estimate_reveal_with_callback_gas(
         &self,
         sender: Address,

apps/fortuna/src/chain/ethereum.rs

@@ -3,7 +3,7 @@ use {
     axum::async_trait,
     ethers::{
         prelude::LogMeta,
-        types::{Address, BlockNumber as EthersBlockNumber, U256},
+        types::{Address, BlockNumber as EthersBlockNumber, Bytes, U256},
     },
 };
 
@@ -54,6 +54,18 @@ pub struct RequestedV2Event {
     pub log_meta: LogMeta,
 }
 
+/// A v2 `Revealed` event that cleared a request on chain.
+#[derive(Clone)]
+pub struct RevealedV2Event {
+    pub provider_revelation: [u8; 32],
+    pub random_number: [u8; 32],
+    pub callback_failed: bool,
+    pub callback_return_value: Bytes,
+    pub callback_gas_used: u32,
+    pub gas_used: U256,
+    pub log_meta: LogMeta,
+}
+
 /// EntropyReader is the read-only interface of the Entropy contract.
 #[async_trait]
 pub trait EntropyReader: Send + Sync {
@@ -75,6 +87,15 @@ pub trait EntropyReader: Send + Sync {
         provider: Address,
     ) -> Result<Vec<RequestedV2Event>>;
 
+    /// Find the v2 `Revealed` event that cleared `(provider, sequence_number)`, searching
+    /// `[from_block, latest]`. Returns `None` if no such reveal is on chain (e.g. reorged out).
+    async fn get_revealed_event(
+        &self,
+        provider: Address,
+        sequence_number: u64,
+        from_block: BlockNumber,
+    ) -> Result<Option<RevealedV2Event>>;
+
     /// Estimate the gas required to reveal a random number with a callback.
     async fn estimate_reveal_with_callback_gas(
         &self,
@@ -235,6 +256,15 @@ pub mod mock {
             Ok(vec![])
         }
 
+        async fn get_revealed_event(
+            &self,
+            _provider: Address,
+            _sequence_number: u64,
+            _from_block: BlockNumber,
+        ) -> Result<Option<super::RevealedV2Event>> {
+            Ok(None)
+        }
+
         async fn estimate_reveal_with_callback_gas(
             &self,
             _sender: Address,