pub async fn process_proof_status(
        &self,
        request_id: B256,
        remaining_timeout: Option<Duration>,
    ) -> Result<(Option<SP1ProofWithPublicValues>, FulfillmentStatus)> {
        // Get the status.
        let (status, maybe_proof): (GetProofRequestStatusResponse, Option<ProofFromNetwork>) =
            self.client.get_proof_request_status(request_id, remaining_timeout).await?;

        let maybe_proof = maybe_proof.map(Into::into);

        // Check if current time exceeds deadline. If so, the proof has timed out.
        let current_time =
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
        if current_time > status.deadline {
            return Err(Error::RequestTimedOut { request_id: request_id.to_vec() }.into());
        }

        // Get the execution and fulfillment statuses.
        let execution_status = ExecutionStatus::try_from(status.execution_status).unwrap();
        let fulfillment_status = FulfillmentStatus::try_from(status.fulfillment_status).unwrap();

        // Check the execution status.
        if execution_status == ExecutionStatus::Unexecutable {
            return Err(Error::RequestUnexecutable { request_id: request_id.to_vec() }.into());
        }

        // Check the fulfillment status.
        if fulfillment_status == FulfillmentStatus::Fulfilled {
            return Ok((maybe_proof, fulfillment_status));
        }
        if fulfillment_status == FulfillmentStatus::Unfulfillable {
            return Err(Error::RequestUnfulfillable { request_id: request_id.to_vec() }.into());
        }

        Ok((None, fulfillment_status))
    }
Gets the status of a proof request with handling for timeouts and unfulfillable requests.

Returns the proof if it is fulfilled and the fulfillment status. Handles statuses indicating
that the proof is unfulfillable or unexecutable with errors.

# Details
* `request_id`: The request ID to get the status of.
* `remaining_timeout`: The remaining timeout for the proof request.

# Example
```rust,no_run
use sp1_sdk::{network::B256, ProverClient};

tokio_test::block_on(async {
let request_id = B256::from_slice(&vec![1u8; 32]);
let client = ProverClient::builder().network().build();
let (maybe_proof, fulfillment_status) =
client.process_proof_status(request_id, None).await.unwrap();
})
```
crates/sdk/src/network/prover.rs