feat: change query tx status loop (#2035)

Author: mateuszjasiuk

apps/namadillo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@namada/namadillo",
-  "version": "1.20.0-hotfix3",
+  "version": "1.20.0-hotfix4",
   "description": "Namadillo",
   "repository": "https://github.com/anoma/namada-interface/",
   "author": "Heliax Dev <info@heliax.dev>",

apps/namadillo/src/App/Common/Toast.tsx

@@ -129,7 +129,9 @@ const Toast = ({ notification, onClose }: ToastProps): JSX.Element => {
           )}
         {notification.details &&
           (viewDetails || notification.type === "error") && (
-            <div className="w-full text-xs text-white block">
+            <div className="w-full text-xs text-white block whitespace-pre-wrap">
+              {/* We "prefix" the error message with a line break to make it more visible */}
+              {notification.type === "error" && <br />}
               {notification.details}
             </div>
           )}

apps/namadillo/src/utils/index.ts

@@ -141,10 +141,10 @@ export const toErrorDetail = (
     // TODO: Over time we may expand this to format errors for more result codes
     switch (code) {
       case ResultCode.TxGasLimit:
-        return `${error.toString()} ${toGasMsg(args.gasLimit)}`;
+        return `${error.toString()}.\n${toGasMsg(args.gasLimit)}`;
       case ResultCode.WasmRuntimeError:
         // We can only check error type by reading the error message
-        return error.toString() + ` ${textToErrorDetail(info, tx[0])}`;
+        return `${error.toString()}.\n${textToErrorDetail(info, tx[0])}`;
 
       default:
         return error.toString() + ` ${info}`;

packages/shared/lib/src/sdk/io.rs

@@ -9,12 +9,9 @@ fn read(question: Option<&str>) -> std::io::Result<String> {
                 .prompt_with_message(question)
                 .expect("Prompt to be defined");
 
-            input.ok_or(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "Input is null",
-            ))
+            input.ok_or(std::io::Error::other("Input is null"))
         }
-        None => Err(std::io::Error::new(std::io::ErrorKind::Other, "No window")),
+        None => Err(std::io::Error::other("No window")),
     }
 }
 

packages/shared/lib/src/sdk/masp/masp_web.rs

@@ -77,7 +77,7 @@ impl WebShieldedUtils {
     }
 
     fn to_io_err(e: Error) -> std::io::Error {
-        std::io::Error::new(std::io::ErrorKind::Other, e.to_string())
+        std::io::Error::other(e.to_string())
     }
 
     pub async fn build_database(chain_id: &str) -> Result<Rexie, Error> {

packages/shared/lib/src/sdk/mod.rs

@@ -24,6 +24,7 @@ use namada_sdk::borsh::{self, BorshDeserialize};
 use namada_sdk::collections::HashMap;
 use namada_sdk::control_flow::time;
 use namada_sdk::eth_bridge::bridge_pool::build_bridge_pool_tx;
+use namada_sdk::events::Event;
 use namada_sdk::hash::Hash;
 use namada_sdk::ibc::convert_masp_tx_to_ibc_memo;
 use namada_sdk::ibc::core::host::types::identifiers::{ChannelId, PortId};
@@ -337,6 +338,44 @@ impl Sdk {
         to_js_result(borsh::to_vec(&namada_tx)?)
     }
 
+    // We query tx evcents in loop here as control flow in namada_sdk does not seem to work well in
+    // browsers
+    async fn query_tx_result(&self, deadline: u64, tx_hash: &str) -> Result<Event, JsValue> {
+        let mut backoff = 0;
+        let deadline = time::Instant::now() + time::Duration::from_secs(deadline);
+        let tx_query = rpc::TxEventQuery::Applied(tx_hash);
+
+        let event = loop {
+            // We do linear backoff here to avoid hammering the RPC server
+            backoff += 1000;
+
+            if time::Instant::now() >= deadline {
+                break Err(JsValue::from("Timed out waiting for tx to be applied"));
+            }
+            let res = rpc::query_tx_events(self.namada.client(), tx_query).await;
+
+            let maybe_response = match res {
+                Ok(response) => response,
+                Err(_) => {
+                    crate::utils::sleep(backoff).await;
+                    continue;
+                }
+            };
+
+            match maybe_response {
+                Some(res) => {
+                    break Ok(res);
+                }
+                None => {
+                    crate::utils::sleep(backoff).await;
+                    continue;
+                }
+            }
+        }?;
+
+        Ok(event)
+    }
+
     pub async fn broadcast_tx(&self, tx_bytes: &[u8], deadline: u64) -> Result<JsValue, JsValue> {
         #[derive(serde::Serialize)]
         struct TxErrResponse {
@@ -363,11 +402,7 @@ impl Sdk {
                     ));
                 }
 
-                let deadline = time::Instant::now() + time::Duration::from_secs(deadline);
-                let tx_query = rpc::TxEventQuery::Applied(tx_hash.as_str());
-                let event = rpc::query_tx_status(&self.namada, tx_query, deadline)
-                    .await
-                    .map_err(|e| JsValue::from_str(&e.to_string()))?;
+                let event = self.query_tx_result(deadline, &tx_hash).await?;
                 let tx_response = TxResponse::from_event(event);
 
                 let mut batch_tx_results: Vec<tx::BatchTxResult> = vec![];

packages/shared/lib/src/sdk/tx.rs

@@ -450,7 +450,11 @@ pub struct BatchTxResult {
 
 impl BatchTxResult {
     pub fn new(hash: String, is_applied: bool, error: Option<String>) -> BatchTxResult {
-        BatchTxResult { hash, is_applied, error }
+        BatchTxResult {
+            hash,
+            is_applied,
+            error,
+        }
     }
 }
 

packages/shared/lib/src/utils.rs

@@ -1,8 +1,9 @@
 use gloo_utils::format::JsValueSerdeExt;
-use js_sys::Uint8Array;
+use js_sys::{Promise, Uint8Array};
 use serde::Serialize;
 use std::fmt::Debug;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
 
 #[wasm_bindgen]
 extern "C" {
@@ -44,3 +45,15 @@ pub fn set_panic_hook() {
     web_sys::console::log_1(&"Set panic hook".into());
     console_error_panic_hook::set_once();
 }
+
+/// Sleep function using setTimeout wrapped in a JS Promise
+pub async fn sleep(ms: i32) {
+    let promise = Promise::new(&mut |resolve, _reject| {
+        web_sys::window()
+            .unwrap()
+            .set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms)
+            .unwrap();
+    });
+
+    let _ = JsFuture::from(promise).await;
+}