app/wallet: cleanup

bin/app/src/app/schema/wallet/main.rs

@@ -16,14 +16,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi::util::parse::encode_base10;
-use darkfi_serial::{Decodable, Encodable};
+use darkfi_serial::Decodable;
 
 use crate::{
     app::{
         App,
         node::{create_button, create_layer, create_text, create_tokentable, create_vector_art},
-        schema::{COLOR_SCHEME, wallet::netstatus},
+        schema::COLOR_SCHEME,
     },
     expr,
     gfx::gfxtag,
@@ -31,7 +30,7 @@ use crate::{
     prop::{PropertyAtomicGuard, PropertyBool, PropertyFloat32, Role},
     scene::{SceneNodePtr, Slot},
     shape,
-    ui::{Button, Layer, Text, TokenRow, TokenTable, VectorArt, VectorShape},
+    ui::{Button, Layer, Text, TokenTable, VectorArt, VectorShape},
     util::i18n::I18nBabelFish,
 };
 
@@ -55,8 +54,6 @@ pub async fn make(
     cc.add_const_f32("BUTTON_FONTSIZE", BUTTON_FONTSIZE);
     cc.add_const_f32("ROW_HEIGHT", ROW_HEIGHT);
 
-    let wallet_is_visible = PropertyBool::wrap(&wallet_layer, Role::App, "is_visible", 0).unwrap();
-
     // ============================================
     // Main Wallet Layer
     // ============================================
@@ -307,7 +304,6 @@ pub async fn make(
     prop.set_expr(atom, Role::App, 2, expr::load_var("w")).unwrap();
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
     tokens_table.set_property_f32(atom, Role::App, "font_size", BASE_FONTSIZE).unwrap();
-    tokens_table.set_property_f32(atom, Role::App, "column_spacing", TOKEN_NAME_OFFSET).unwrap();
     tokens_table.set_property_f32(atom, Role::App, "padding_x", PADDING_X).unwrap();
     tokens_table.set_property_f32(atom, Role::App, "padding_y", PADDING_Y).unwrap();
     tokens_table.set_property_u32(atom, Role::App, "z_index", 2).unwrap();

bin/app/src/app/schema/wallet/mod.rs

@@ -34,7 +34,6 @@ pub mod netstatus;
 use crate::{
     app::{App, node::create_layer},
     expr,
-    gfx::gfxtag,
     prop::{PropertyAtomicGuard, PropertyFloat32, Role},
     scene::SceneNodePtr,
     ui::Layer,

bin/app/src/app/schema/wallet/netstatus.rs

@@ -33,8 +33,8 @@ use crate::{
 pub async fn make(
     app: &App,
     wallet_layer: SceneNodePtr,
-    i18n_fish: &I18nBabelFish,
-    window_scale: PropertyFloat32,
+    _i18n_fish: &I18nBabelFish,
+    _window_scale: PropertyFloat32,
 ) -> SceneNodePtr {
     let atom = &mut PropertyAtomicGuard::none();
 

bin/app/src/app/schema/wallet/send.rs

@@ -66,33 +66,26 @@ pub async fn make(
         i18n_fish,
         window_scale.clone(),
         send_tx_data.clone(),
-        step1_is_visible.clone(),
         step2_is_visible.clone(),
     ).await;
 
     let step3_is_visible = PropertyBool::wrap(&send_step3_layer, Role::App, "is_visible", 0).unwrap();
 
-    let send_step4_layer = send_step4::make(
+    let _send_step4_layer = send_step4::make(
         app,
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
         send_tx_data.clone(),
-        step2_is_visible.clone(),
         step3_is_visible.clone(),
-        step1_is_visible.clone(),
     ).await;
 
-    let step4_is_visible = PropertyBool::wrap(&send_step4_layer, Role::App, "is_visible", 0).unwrap();
-
     let tx_status_layer = tx_status::make(
         app,
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
         send_tx_data,
-        step3_is_visible,
-        step4_is_visible,
     ).await;
 
     // Add listener for tx built signal to update send button label and show fee
@@ -104,7 +97,7 @@ pub async fn make(
             let mut cur = std::io::Cursor::new(mcall.data);
             let tx = Transaction::decode(&mut cur).unwrap();
             let mut fees: u64 = 0;
-            for (i, call) in tx.calls.iter().enumerate() {
+            for call in tx.calls.iter() {
                 if call.data.is_money_fee() {
                     if let Ok(fee) = darkfi_serial::deserialize(&call.data.data[1..9]) {
                         fees = fees.saturating_add(fee);
@@ -115,7 +108,7 @@ pub async fn make(
             let atom = &mut renderer_for_built.make_guard(gfxtag!("tx built - update send button"));
 
             // Make send button active
-            if let Some(send_label_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_label") {
+            if let Some(send_label_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_btn_label") {
                 send_label_node.set_property_str(atom, Role::App, "text", "send").unwrap();
                 let prop = send_label_node.get_property("text_color").unwrap();
                 prop.set_f32(atom, Role::App, 0, COLOR_CYAN[0]).unwrap();
@@ -123,10 +116,10 @@ pub async fn make(
                 prop.set_f32(atom, Role::App, 2, COLOR_CYAN[2]).unwrap();
                 prop.set_f32(atom, Role::App, 3, COLOR_CYAN[3]).unwrap();
             }
-            if let Some(send_bg_grey_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg_grey") {
+            if let Some(send_bg_grey_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg_grey") {
                 send_bg_grey_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
             }
-            if let Some(send_bg_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg") {
+            if let Some(send_bg_node) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg") {
                 send_bg_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
 

bin/app/src/app/schema/wallet/send_step1.rs

@@ -18,9 +18,7 @@
 
 use std::sync::Arc;
 
-use darkfi::util::parse::encode_base10;
-use darkfi_money_contract::model::DARK_TOKEN_ID;
-use darkfi_serial::{Decodable, Encodable};
+use darkfi_serial::Decodable;
 
 use crate::{
     app::{
@@ -133,7 +131,6 @@ pub async fn make(
     prop.set_expr(atom, Role::App, 2, expr::load_var("w")).unwrap();
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
     send_tokens_table.set_property_f32(atom, Role::App, "font_size", BASE_FONTSIZE).unwrap();
-    send_tokens_table.set_property_f32(atom, Role::App, "column_spacing", TOKEN_NAME_OFFSET).unwrap();
     send_tokens_table.set_property_f32(atom, Role::App, "padding_x", PADDING_X).unwrap();
     send_tokens_table.set_property_f32(atom, Role::App, "padding_y", PADDING_Y).unwrap();
     send_tokens_table.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
@@ -192,50 +189,5 @@ pub async fn make(
     });
     app.tasks.lock().unwrap().push(listen_click);
 
-    let step1_is_visible3 = step1_is_visible.clone();
-    let sg_root2 = app.sg_root.clone();
-    let renderer2 = app.renderer.clone();
-    let send_tokens_table2 = send_tokens_table.clone();
-    let step1_is_visible_sub = step1_is_visible.prop().subscribe_modify();
-    let listen_step1_visible = app.ex.spawn(async move {
-        while let Ok(_) = step1_is_visible_sub.receive().await {
-            if step1_is_visible3.get() {
-                let atom = &mut renderer2.make_guard(gfxtag!("wallet - refresh send tokens"));
-
-                if let Some(drk_node) = sg_root2.lookup_node("/plugin/drk") {
-                    if let Ok(Some(response_data)) = drk_node.call_method("get_balances", vec![]).await {
-                        let mut cur = std::io::Cursor::new(response_data);
-                        if let Ok(balances) = Vec::<(String, darkfi_money_contract::model::TokenId, u64)>::decode(&mut cur) {
-                            let token_rows: Vec<TokenRow> = balances
-                                .iter()
-                                .enumerate()
-                                .map(|(i, (symbol, token_id, balance))| TokenRow {
-                                    id: *token_id,
-                                    symbol: symbol.clone(),
-                                    balance: encode_base10(*balance, BALANCE_BASE10_DECIMALS),
-                                })
-                                .collect();
-
-                            let mut data: Vec<u8> = vec![];
-                            for row in &token_rows {
-                                let _ = TokenRow::encode(row, &mut data);
-                            }
-
-                            let _ = send_tokens_table2.call_method("set_tokens", data).await;
-
-                            // Update main wallet balance
-                            if let Some(drk_row) = token_rows.iter().find(|row| row.id == *DARK_TOKEN_ID) {
-                                if let Some(balance_node) = sg_root2.lookup_node("/window/content/wallet/main_layer/wallet_balance") {
-                                    balance_node.set_property_str(atom, Role::App, "text", format!("DRK {}", drk_row.balance)).unwrap();
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-    app.tasks.lock().unwrap().push(listen_step1_visible);
-
     send_step1_layer
 }

bin/app/src/app/schema/wallet/send_step2.rs

@@ -17,7 +17,6 @@
  */
 
 use std::sync::Arc;
-use darkfi::util::parse::encode_base10;
 use darkfi_sdk::crypto::keypair::Address;
 
 use crate::{
@@ -104,9 +103,6 @@ pub async fn make(
     wallet_layer.link(send_step2_layer.clone());
     let step2_is_visible = PropertyBool::wrap(&send_step2_layer, Role::App, "is_visible", 0).unwrap();
 
-    let step3_is_visible = app.sg_root.lookup_node("/window/content/wallet/send_step3_layer")
-        .and_then(|l| PropertyBool::wrap(&l, Role::App, "is_visible", 0).ok());
-
     create_bg_mesh(app, atom, &send_step2_layer, "send_bg2").await;
     create_header_bg(app, atom, &send_step2_layer, "send_header_bg2").await;
 
@@ -348,8 +344,6 @@ pub async fn make(
     let node = node.setup(|me| Button::new(me, app.renderer.clone())).await;
     send_step2_layer.link(node);
 
-    y += RECIPIENT_INPUT_MARGIN + RECIPIENT_INPUT_HEIGHT;
-
     // Add recipient button
     let (node, btn_bg_valid, btn_bg_invalid, add_recipient_label_node) = create_bottom_button_with_states(
         app,
@@ -441,12 +435,6 @@ pub async fn make(
                     if let Pimpl::Edit(edit) = token_symbol_node.pimpl() {
                         edit.on_text_prop_changed();
                     }
-
-                    // Update available balance
-                    let available_balance = encode_base10(get_balance(&sg_root, &data.token_id.unwrap()).await, BALANCE_BASE10_DECIMALS);
-                    if let Some(available_balance_node) = sg_root.lookup_node("/window/content/wallet/send_step3_layer/send_available_balance") {
-                        available_balance_node.set_property_str(atom, Role::App, "text", format!("{available_balance} available")).unwrap();
-                    }
                 }
             }
             if let Some(recipient_str) = &data.recipient_str {

bin/app/src/app/schema/wallet/send_step3.rs

@@ -45,7 +45,6 @@ pub async fn make(
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
     send_tx_data: Arc<std::sync::Mutex<SendTxData>>,
-    step1_is_visible: PropertyBool,
     step2_is_visible: PropertyBool,
 ) -> SceneNodePtr {
     let atom = &mut PropertyAtomicGuard::none();
@@ -77,9 +76,6 @@ pub async fn make(
     wallet_layer.link(send_step3_layer.clone());
     let step3_is_visible = PropertyBool::wrap(&send_step3_layer, Role::App, "is_visible", 0).unwrap();
 
-    let step4_is_visible = app.sg_root.lookup_node("/window/content/wallet/send_step4_layer")
-        .and_then(|l| PropertyBool::wrap(&l, Role::App, "is_visible", 0).ok());
-
     create_bg_mesh(app, atom, &send_step3_layer, "send_bg3").await;
     create_header_bg(app, atom, &send_step3_layer, "send_header_bg3").await;
 
@@ -471,8 +467,6 @@ pub async fn make(
         .await;
     amount_wrapper.link(token_symbol_node.clone());
 
-    y += PADDING_Y * 2. + BUTTON_HEIGHT + 10.;
-
     // Add amount button with states
     let (node, btn_bg_valid, btn_bg_invalid, add_amount_label_node) = create_bottom_button_with_states(
         app,
@@ -524,10 +518,9 @@ pub async fn make(
                 (data.token_id, data.token_symbol.clone().unwrap_or_default())
             };
             if let Some(token_id) = token_id {
-                update_amount_screen(
+                let available_balance = update_amount_screen(
                     atom,
                     &sg_root,
-                    &sanitized_amount,
                     &token_id,
                     &token_symbol,
                     &amount_wrapper2,
@@ -535,7 +528,6 @@ pub async fn make(
                     &token_symbol_node2,
                     Some(&available_balance_node2),
                 ).await;
-                let available_balance = get_balance(&sg_root, &token_id).await;
                 let is_valid = if sanitized_amount == "0" {
                     false
                 } else {
@@ -597,19 +589,24 @@ pub async fn make(
                 // Store the amount (use sanitized value)
                 let mut data = send_tx_data4.lock().unwrap();
                 data.amount = Some(sanitized_text.clone());
+                let token_symbol = data.token_symbol.clone().unwrap();
+                let recipient_str = data.recipient_str.clone().unwrap();
+                let amount = data.amount.clone().unwrap();
+                let token_id = data.token_id;
+                let recipient = data.recipient;
 
                 // Update step4 display with transaction data
                 if let Some(token_symbol_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_selected_token_symbol4") {
-                    token_symbol_node.set_property_str(atom, Role::App, "text", &data.token_symbol.clone().unwrap()).unwrap();
+                    token_symbol_node.set_property_str(atom, Role::App, "text", &token_symbol).unwrap();
                 }
                 if let Some(amount_token_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_amount_wrapper4/send_amount_token_symbol4") {
-                    amount_token_node.set_property_str(atom, Role::App, "text", &data.token_symbol.clone().unwrap()).unwrap();
+                    amount_token_node.set_property_str(atom, Role::App, "text", &token_symbol).unwrap();
                 }
                 if let Some(recipient_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_recipient_value4") {
-                    recipient_node.set_property_str(atom, Role::App, "text", &data.recipient_str.clone().unwrap()).unwrap();
+                    recipient_node.set_property_str(atom, Role::App, "text", &recipient_str).unwrap();
                 }
                 if let Some(amount_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_amount_wrapper4/send_amount_text4") {
-                    amount_node.set_property_str(atom, Role::App, "text", &data.amount.clone().unwrap()).unwrap();
+                    amount_node.set_property_str(atom, Role::App, "text", &amount).unwrap();
                 }
 
                 // Switch to step4 and set send button to "building tx..."
@@ -617,7 +614,7 @@ pub async fn make(
                 if let Some(step4) = sg_root.lookup_node("/window/content/wallet/send_step4_layer") {
                     step4.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
                 }
-                if let Some(send_label_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_label") {
+                if let Some(send_label_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_btn_label") {
                     send_label_node.set_property_str(atom, Role::App, "text", "building tx...").unwrap();
                     let prop = send_label_node.get_property("text_color").unwrap();
                     prop.set_f32(atom, Role::App, 0, 0.5).unwrap();
@@ -625,21 +622,21 @@ pub async fn make(
                     prop.set_f32(atom, Role::App, 2, 0.5).unwrap();
                     prop.set_f32(atom, Role::App, 3, 1.).unwrap();
                 }
-                if let Some(send_bg_grey_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg_grey") {
+                if let Some(send_bg_grey_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg_grey") {
                     send_bg_grey_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
                 }
-                if let Some(send_bg_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg") {
+                if let Some(send_bg_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg") {
                     send_bg_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
                 }
 
                 // Build the transaction via DrkPlugin
                 if let (Some(drk_node), Some(token_id), Some(recipient)) = (
                     sg_root.lookup_node("/plugin/drk"),
-                    data.token_id,
-                    data.recipient,
+                    token_id,
+                    recipient,
                 ) {
                     let mut encoded_data = vec![];
-                    data.amount.clone().unwrap().encode(&mut encoded_data).unwrap();
+                    amount.encode(&mut encoded_data).unwrap();
                     token_id.encode(&mut encoded_data).unwrap();
                     recipient.public_key().encode(&mut encoded_data).unwrap();
 
@@ -682,11 +679,9 @@ pub async fn make(
                 if let Some(token_id) = token_id {
                     if !token_symbol.is_empty() {
                         let atom = &mut renderer_clone.make_guard(gfxtag!("update amount positions on visible"));
-                        let current_amount = input_node_clone.get_property_str("text").unwrap();
                         update_amount_screen(
                             atom,
                             &sg_root,
-                            &current_amount,
                             &token_id,
                             &token_symbol,
                             &amount_wrapper_clone,

bin/app/src/app/schema/wallet/send_step4.rs

@@ -43,9 +43,7 @@ pub async fn make(
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
     send_tx_data: Arc<std::sync::Mutex<SendTxData>>,
-    step2_is_visible: PropertyBool,
     step3_is_visible: PropertyBool,
-    step1_is_visible: PropertyBool,
 ) -> SceneNodePtr {
     let atom = &mut PropertyAtomicGuard::none();
 
@@ -76,9 +74,6 @@ pub async fn make(
     wallet_layer.link(send_step4_layer.clone());
     let step4_is_visible = PropertyBool::wrap(&send_step4_layer, Role::App, "is_visible", 0).unwrap();
 
-    let tx_status_is_visible = app.sg_root.lookup_node("/window/content/wallet/tx_status_layer")
-        .and_then(|l| PropertyBool::wrap(&l, Role::App, "is_visible", 0).ok());
-
     create_bg_mesh(app, atom, &send_step4_layer, "send_bg4").await;
     create_header_bg(app, atom, &send_step4_layer, "send_header_bg4").await;
 
@@ -107,7 +102,6 @@ pub async fn make(
     let step3_is_visible2 = step3_is_visible.clone();
     let step4_is_visible1 = step4_is_visible.clone();
     let renderer = app.renderer.clone();
-    let sg_root2 = app.sg_root.clone();
     let (slot, recvr) = Slot::new("send_back_clicked4");
     node.register("click", slot).unwrap();
     let listen_click = app.ex.spawn(async move {
@@ -325,24 +319,11 @@ pub async fn make(
     tx_fee_label_node.set_property_f32(atom, Role::App, "font_size", BASE_FONTSIZE).unwrap();
     tx_fee_label_node.set_property_str(atom, Role::App, "text", "Transaction fee").unwrap();
     let prop = tx_fee_label_node.get_property("text_color").unwrap();
-    if COLOR_SCHEME == ColorScheme::DarkMode {
-        prop.set_f32(atom, Role::App, 0, 1.).unwrap();
-        prop.set_f32(atom, Role::App, 1, 1.).unwrap();
-        prop.set_f32(atom, Role::App, 2, 1.).unwrap();
-        prop.set_f32(atom, Role::App, 3, 1.).unwrap();
-    } else {
-        prop.set_f32(atom, Role::App, 0, 0.).unwrap();
-        prop.set_f32(atom, Role::App, 1, 0.).unwrap();
-        prop.set_f32(atom, Role::App, 2, 0.).unwrap();
-        prop.set_f32(atom, Role::App, 3, 1.).unwrap();
-    }
-    tx_fee_label_node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
-    tx_fee_label_node.set_property_f32(atom, Role::App, "font_size", BASE_FONTSIZE).unwrap();
-    let prop = tx_fee_label_node.get_property("text_color").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
     prop.set_f32(atom, Role::App, 2, 0.).unwrap();
     prop.set_f32(atom, Role::App, 3, 0.).unwrap();
+    tx_fee_label_node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let tx_fee_label_node = tx_fee_label_node.setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone())).await;
     send_step4_layer.link(tx_fee_label_node.clone());
 
@@ -377,14 +358,12 @@ pub async fn make(
         "h - PADDING_X * 2 - BUTTON_HEIGHT",
     ).await;
 
-    y += PADDING_Y * 2. + BUTTON_HEIGHT + 10.;
-
     // Send button (bottom button)
     let (node, _bg_valid, _bg_invalid, _label) = create_bottom_button_with_states(
         app,
         atom,
         &send_step4_layer,
-        "send_send_btn",
+        "send_btn",
         &mut cc,
         "send",
         &window_scale,
@@ -396,12 +375,12 @@ pub async fn make(
     let sg_root = app.sg_root.clone();
     let step4_is_visible1 = step4_is_visible.clone();
     let send_tx_data_for_send = send_tx_data.clone();
-    let (slot, recvr) = Slot::new("send_send_clicked");
+    let (slot, recvr) = Slot::new("send_clicked");
     node.register("click", slot).unwrap();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             // Skip if the button is disabled
-            if let Some(btn_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg") {
+            if let Some(btn_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg") {
                 if !btn_node.get_property_bool("is_visible").unwrap() {
                     continue;
                 }
@@ -462,7 +441,6 @@ pub async fn make(
                 let atom = &mut renderer_clone.make_guard(gfxtag!("update step4 amount positions"));
                 let data = send_tx_data_clone2.lock().unwrap().clone();
 
-                let amount_text = data.amount.unwrap_or_else(|| "0".to_string());
                 let token_symbol = data.token_symbol.unwrap_or_else(|| "".to_string());
                 let token_id = data.token_id.unwrap();
 
@@ -470,7 +448,6 @@ pub async fn make(
                 update_amount_screen(
                     atom,
                     &sg_root,
-                    &amount_text,
                     &token_id,
                     &token_symbol,
                     &amount_wrapper_clone,
@@ -481,7 +458,7 @@ pub async fn make(
 
                 if data.tx_built {
                     // Set send button label
-                    if let Some(send_label_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_label") {
+                    if let Some(send_label_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_btn_label") {
                         send_label_node.set_property_str(atom, Role::App, "text", "send").unwrap();
                     }
                     // Show transaction fee

bin/app/src/app/schema/wallet/tx_status.rs

@@ -43,8 +43,6 @@ pub async fn make(
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
     send_tx_data: Arc<std::sync::Mutex<SendTxData>>,
-    step3_is_visible: PropertyBool,
-    step4_is_visible: PropertyBool,
 ) -> SceneNodePtr {
     let atom = &mut PropertyAtomicGuard::none();
 
@@ -251,7 +249,6 @@ pub async fn make(
     let tx_status_layer_clone = tx_status_layer.clone();
     let sg_root = app.sg_root.clone();
     let renderer = app.renderer.clone();
-    let send_tx_data2 = send_tx_data.clone();
     app.tasks.lock().unwrap().push(app.ex.spawn(async move {
         while let Ok(mcall) = set_tx_status_sub.receive().await {
             let atom = &mut renderer.make_guard(gfxtag!("set_tx_status"));
@@ -287,7 +284,6 @@ pub async fn make(
 
     // Subscribe to method for receiving built transaction
     let set_built_tx_sub = tx_status_layer.subscribe_method_call("set_built_tx").unwrap();
-    let renderer = app.renderer.clone();
     let send_tx_data2 = send_tx_data.clone();
     app.tasks.lock().unwrap().push(app.ex.spawn(async move {
         while let Ok(mcall) = set_built_tx_sub.receive().await {

bin/app/src/app/schema/wallet/util.rs

@@ -59,14 +59,13 @@ pub async fn get_balance(sg_root: &SceneNodePtr, token_id: &TokenId) -> u64 {
 pub async fn update_amount_screen(
     atom: &mut PropertyAtomicGuard,
     sg_root: &SceneNodePtr,
-    amount_text: &str,
     token_id: &TokenId,
     token_symbol: &str,
     amount_wrapper_node: &SceneNodePtr,
     amount_input_node: &SceneNodePtr,
     token_node: &SceneNodePtr,
     available_balance_node: Option<&SceneNodePtr>,
-) {
+) -> u64 {
     let mut cc = expr::Compiler::new();
 
     let amount_input_text = amount_input_node.get_property_str("text").unwrap();
@@ -102,10 +101,13 @@ pub async fn update_amount_screen(
     token_rect.set_expr(atom, Role::App, 0, cc.compile("AMOUNT_TOKEN_SPACING + AMOUNT_WIDTH").unwrap()).unwrap();
 
     // Set available balance
+    let balance = get_balance(sg_root, token_id).await;
     if let Some(available_balance_node) = available_balance_node {
-        let available_balance = encode_base10(get_balance(sg_root, token_id).await, BALANCE_BASE10_DECIMALS);
+        let available_balance = encode_base10(balance, BALANCE_BASE10_DECIMALS);
         available_balance_node.set_property_str(atom, Role::App, "text", format!("{available_balance} available")).unwrap();
     }
+
+    balance
 }
 
 /// Creates a title text node with separator line.

bin/app/src/main.rs

@@ -507,8 +507,7 @@ async fn load_plugins(
                 if let Ok(balances) = Vec::<(String, TokenId, u64)>::decode(&mut cur) {
                     let token_rows: Vec<TokenRow> = balances
                         .iter()
-                        .enumerate()
-                        .map(|(i, (symbol, token_id, balance))| {
+                        .map(|(symbol, token_id, balance)| {
                             TokenRow {
                                 id: *token_id,
                                 symbol: symbol.clone(),
@@ -633,7 +632,7 @@ async fn load_plugins(
             }
 
             // Reset step4 send button to disabled state
-            if let Some(send_label_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_label") {
+            if let Some(send_label_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_btn_label") {
                 send_label_node.set_property_str(atom, Role::App, "text", "send").unwrap();
                 let prop = send_label_node.get_property("text_color").unwrap();
                 prop.set_f32(atom, Role::App, 0, 0.5).unwrap();
@@ -641,10 +640,10 @@ async fn load_plugins(
                 prop.set_f32(atom, Role::App, 2, 0.5).unwrap();
                 prop.set_f32(atom, Role::App, 3, 1.).unwrap();
             }
-            if let Some(send_bg_grey_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg_grey") {
+            if let Some(send_bg_grey_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg_grey") {
                 send_bg_grey_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
-            if let Some(send_bg_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_send_btn_bg") {
+            if let Some(send_bg_node) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer/send_btn_bg") {
                 send_bg_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
             }
 

bin/app/src/plugin/drk.rs

@@ -19,13 +19,12 @@
 use darkfi::{
     system::{Publisher, PublisherPtr, StoppableTask, sleep},
     tx::Transaction,
-    util::parse::encode_base10,
     Result as DarkFiResult,
 };
 use darkfi_money_contract::model::TokenId;
 use darkfi_serial::{serialize, Decodable, Encodable};
 use darkfi_sdk::crypto::{keypair::{Address, Network, PublicKey, StandardAddress}};
-use drk::{Drk, money::BALANCE_BASE10_DECIMALS, rpc::subscribe_blocks};
+use drk::{Drk, rpc::subscribe_blocks};
 use smol::lock::RwLock;
 use smol::channel::unbounded;
 use std::{
@@ -86,8 +85,6 @@ macro_rules! e { ($($arg:tt)*) => { error!(target: "plugin::drk", $($arg)*); } }
 
 #[derive(Debug, Clone)]
 enum TxStatus {
-    Building,
-    Broadcasting,
     Confirming,
     Confirmed,
     Error(String),
@@ -96,8 +93,6 @@ enum TxStatus {
 impl TxStatus {
     fn text(&self) -> String {
         match self {
-            TxStatus::Building => "Building transaction...".to_string(),
-            TxStatus::Broadcasting => "Broadcasting transaction...".to_string(),
             TxStatus::Confirming => "Confirming transaction...".to_string(),
             TxStatus::Confirmed => "Transaction confirmed".to_string(),
             TxStatus::Error(ref err) => format!("Error sending transaction: {err}"),
@@ -301,7 +296,6 @@ impl DrkPlugin {
 
         let mut result: Vec<(String, TokenId, u64)> = Vec::new();
         for (token_id_str, balance) in balances {
-            let encoded = encode_base10(balance, BALANCE_BASE10_DECIMALS);
             let alias = aliases.get(&token_id_str).cloned().unwrap_or_else(|| "UNKN".to_string());
             let token_id = token_id_str.parse::<TokenId>().unwrap();
 
@@ -315,14 +309,14 @@ impl DrkPlugin {
     }
 
     /// Emit balances_updated signal
-    pub async fn emit_balances_updated(&self) {
+    async fn emit_balances_updated(&self) {
         if let Some(node) = self.node.upgrade() {
             let _ = node.trigger("balances_updated", vec![]).await;
         }
     }
 
     /// Emit tx_updated signal
-    pub async fn emit_tx_updated(&self, state: &TxState) {
+    async fn emit_tx_updated(&self, state: &TxState) {
         if let Some(node) = self.node.upgrade() {
             let mut data = vec![];
             state.id.clone().encode(&mut data).unwrap();
@@ -333,7 +327,7 @@ impl DrkPlugin {
             let _ = node.trigger("tx_updated", data).await;
         }
     }
-    pub async fn emit_tx_status_updated(&self, status: &TxStatus) {
+    async fn emit_tx_status_updated(&self, status: &TxStatus) {
         if let Some(node) = self.node.upgrade() {
             let mut data = vec![];
             None::<String>.encode(&mut data).unwrap();
@@ -346,7 +340,7 @@ impl DrkPlugin {
     }
 
     /// Emit tx_built signal when transaction is built
-    pub async fn emit_tx_built(&self, amount: String, token_symbol: String, recipient: Address, tx: Transaction) {
+    async fn emit_tx_built(&self, amount: String, token_symbol: String, recipient: Address, tx: Transaction) {
         if let Some(node) = self.node.upgrade() {
             let mut data = vec![];
             amount.encode(&mut data).unwrap();
@@ -358,7 +352,7 @@ impl DrkPlugin {
     }
 
     /// Emit tx_built_error signal when transaction building fails
-    pub async fn emit_tx_built_error(&self, error: String) {
+    async fn emit_tx_built_error(&self, error: String) {
         if let Some(node) = self.node.upgrade() {
             let mut data = vec![];
             error.encode(&mut data).unwrap();
@@ -621,6 +615,7 @@ impl DrkPlugin {
             recipient: None,
         };
         self_.emit_tx_updated(&state).await;
+        self_.emit_balances_updated().await;
 
         true
     }

bin/app/src/ui/tokentable/mod.rs

@@ -75,7 +75,6 @@ pub struct TokenTable {
     font_size: PropertyFloat32,
     text_color: PropertyColor,
     separator_color: PropertyColor,
-    column_spacing: PropertyFloat32,
     padding_x: PropertyFloat32,
     padding_y: PropertyFloat32,
 
@@ -93,7 +92,6 @@ impl TokenTable {
         let font_size = PropertyFloat32::wrap(node_ref, Role::Internal, "font_size", 0).unwrap();
         let text_color = PropertyColor::wrap(node_ref, Role::Internal, "text_color").unwrap();
         let separator_color = PropertyColor::wrap(node_ref, Role::Internal, "separator_color").unwrap();
-        let column_spacing = PropertyFloat32::wrap(node_ref, Role::Internal, "column_spacing", 0).unwrap();
         let padding_x = PropertyFloat32::wrap(node_ref, Role::Internal, "padding_x", 0).unwrap();
         let padding_y = PropertyFloat32::wrap(node_ref, Role::Internal, "padding_y", 0).unwrap();
         let z_index = PropertyUint32::wrap(node_ref, Role::Internal, "z_index", 0).unwrap();
@@ -111,7 +109,6 @@ impl TokenTable {
             font_size,
             text_color,
             separator_color,
-            column_spacing,
             padding_x,
             padding_y,
             parent_rect: SyncMutex::new(None),