Use an ```ApiResponse``` in a client.

web-client/src/exchange_client.rs

 use common_api::{
-    api::{Data, ExchangeMessage, ParticipantInfo, PublicKeys},
+    api::{ApiResponse, Data, ExchangeMessage, ParticipantInfo, PublicKeys},
     headers::{SignatureHeader, SIGNATURE_HEADER_NAME},
 };
 
     signer: &Signer,
     meet_id: Uuid,
     participants: HashSet<AccountId>,
-) -> Result<Vec<ParticipantInfo>> {
+) -> Result<ApiResponse<Vec<ParticipantInfo>>> {
     let client = client()?;
 
     let public_keys = PublicKeys {
         .and_then(Response::error_for_status)
         .map_err(ApiError::from)?;
 
-    let infos =
-        serde_json::from_slice::<Vec<ParticipantInfo>>(&verify_response(handler, response).await?)
-            .map_err(ApiError::from)?;
+    let infos = serde_json::from_slice::<ApiResponse<Vec<ParticipantInfo>>>(
+        &verify_response(handler, response).await?,
+    )
+    .map_err(ApiError::from)?;
 
     Ok(infos)
 }
 
-pub async fn receive(handler: &Handler, signer: &Signer, meet_id: Uuid) -> Result<Data> {
+pub async fn receive(
+    handler: &Handler,
+    signer: &Signer,
+    meet_id: Uuid,
+) -> Result<ApiResponse<Data>> {
     let client = client()?;
 
     let duration = Duration::from_secs(10);
         .and_then(Response::error_for_status)
         .map_err(ApiError::from)?;
 
-    let data = serde_json::from_slice::<Data>(&verify_response(handler, response).await?)
-        .map_err(ApiError::from)?;
+    let data =
+        serde_json::from_slice::<ApiResponse<Data>>(&verify_response(handler, response).await?)
+            .map_err(ApiError::from)?;
 
     Ok(data)
 }

web-client/src/lib.rs

     view_moderator_account,
 };
 
-use common_api::api::{Data, ExchangeMessage};
+use common_api::api::{ApiResponse, Data, ExchangeMessage};
 use crypto::{decrypt, encrypt, secret};
 use error::ApiError;
 use exchange_client::{exchange, public_keys, receive};
             while !participants.is_empty() {
                 let infos =
                     match public_keys(&handler, &signer, meet_id, participants.clone()).await {
-                        Ok(infos) => infos,
-                        Err(err) => {
-                            warn!("Failed to fetch a public keys, cause {err:?}");
+                        Ok(ApiResponse::Success(infos)) => infos,
+                        Ok(ApiResponse::Timeout) => {
+                            warn!("Timeout happens on a server-side, subscribed one more time");
                             continue;
                         }
+                        Err(err) => {
+                            return Err(ApiError::KeyExchange(format!(
+                                "The send keys operation has been failed, cause {err:?}"
+                            ))
+                            .into());
+                        }
                     };
 
                 // remove infos that is already processed
 
         let get_key = async move {
             let meet_id = Uuid::from_str(&meeting_id).map_err(ApiError::from)?;
-            let data = receive(&handler, &signer, meet_id).await?;
-            let secret = decrypt(signer.secret_key(), data.moderator_pk, meet_id, data.data)?;
-            Ok(JsValue::from_str(&base64::encode(secret)))
+
+            loop {
+                if let ApiResponse::Success(data) = receive(&handler, &signer, meet_id).await? {
+                    let secret =
+                        decrypt(signer.secret_key(), data.moderator_pk, meet_id, data.data)?;
+                    return Ok(JsValue::from_str(&base64::encode(secret)));
+                }
+            }
         };
 
         wasm_bindgen_futures::future_to_promise(async move {