pub async fn execute(&self, request: TEERequest) -> Result<TEEResponse, ClientError> {
        // The server responds with an SSE stream, and the expected response is the first item.
        let payload: EventPayload = self
            .client
            .post(format!("{}/execute", self.url))
            .header("X-SP1-Tee-Version", SP1_TEE_VERSION)
            .body(bincode::serialize(&request)?)
            .send()
            .await?
            .bytes_stream()
            .eventsource()
            .map(|event| match event {
                Ok(event) => {
                    // The event is a hex encoded payload, which we decode and then deserialize.
                    let decoded = hex::decode(&event.data)?;

                    Ok(bincode::deserialize(&decoded)?)
                }
                Err(e) => Err(ClientError::Event(e)),
            })
            .next()
            .await
            .ok_or(ClientError::NoResponse)??;

        // Everything worked as expected, but the handle the case where execution failed.
        match payload {
            EventPayload::Success(response) => Ok(response),
            // This error type may either be an execution error, or an internal server error.
            // For the former, this should have been checked by the caller locally by executing
            // the program.
            EventPayload::Error(error) => Err(ClientError::ServerError(error)),
        }
    }
Execute a request for an "integrity proof" from the TEE server.

This function will send a request to the TEE server, and await a response.

# Errors
- [`ClientError::Http`] - If the request fails to send.
- [`ClientError::Event`] - If the response is not a valid SSE event.
- [`ClientError::Parse`] - If the response fails to be parsed.
- [`ClientError::Decode`] - If the response contains invalid hex.
- [`ClientError::ServerError`] - If the server returns an error.
- [`ClientError::NoResponse`] - If no response is received from the server.
crates/sdk/src/network/tee/client.rs