app/schema/wallet: add a "wallet" layer as a parent of all wallet pages

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

@@ -582,7 +582,7 @@ pub async fn setup_wallet_button(app: &App, menu_layer: SceneNodePtr, i18n_fish:
     node.register("click", slot).unwrap();
     let sg_root = app.sg_root.clone();
     let wallet_is_visible =
-        PropertyBool::wrap(&sg_root.lookup_node("/window/content/wallet_main_layer").unwrap(), Role::App, "is_visible", 0).unwrap();
+        PropertyBool::wrap(&sg_root.lookup_node("/window/content/wallet").unwrap(), Role::App, "is_visible", 0).unwrap();
     let renderer = app.renderer.clone();
     let menulayer_is_visible2 = menulayer_is_visible.clone();
     let listen_click = app.ex.spawn(async move {

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

@@ -39,7 +39,7 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_main_wallet_layer(
     app: &App,
-    content: SceneNodePtr,
+    wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
 ) -> SceneNodePtr {
@@ -55,24 +55,26 @@ pub async fn make_main_wallet_layer(
     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
     // ============================================
-    let wallet_layer = create_layer("wallet_main_layer");
-    let prop = wallet_layer.get_property("rect").unwrap();
+    let main_layer = create_layer("main_layer");
+    let prop = main_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
     prop.set_expr(atom, Role::App, 2, expr::load_var("w")).unwrap();
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
-    wallet_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
-    wallet_layer.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let wallet_layer = wallet_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(wallet_layer.clone());
+    main_layer.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
+    main_layer.set_property_u32(atom, Role::App, "z_index", 19).unwrap();
+    let main_layer = main_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
+    wallet_layer.link(main_layer.clone());
 
-    let wallet_is_visible = PropertyBool::wrap(&wallet_layer, Role::App, "is_visible", 0).unwrap();
+    let main_is_visible = PropertyBool::wrap(&main_layer, Role::App, "is_visible", 0).unwrap();
 
-    create_bg_mesh(app, atom, &wallet_layer, "wallet_bg").await;
-    create_header_bg(app, atom, &wallet_layer, "wallet_header_bg").await;
+    create_bg_mesh(app, atom, &main_layer, "wallet_bg").await;
+    create_header_bg(app, atom, &main_layer, "wallet_header_bg").await;
 
     // Back button
     let node = create_vector_art("wallet_back_btn_bg");
@@ -84,7 +86,7 @@ pub async fn make_main_wallet_layer(
     node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let shape = shape::create_back_arrow().scaled(BACKARROW_SCALE);
     let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     let node = create_button("wallet_back_btn");
     node.set_property_bool(atom, Role::App, "is_active", true).unwrap();
@@ -117,7 +119,7 @@ pub async fn make_main_wallet_layer(
     app.tasks.lock().unwrap().push(listen_click);
 
     let node = node.setup(|me| Button::new(me, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     let mut y = HEADER_HEIGHT;
 
@@ -146,14 +148,14 @@ pub async fn make_main_wallet_layer(
     let node = node
         .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     y += TITLE_PADDING * 2. + TITLE_FONTSIZE + 1.;
 
-    create_separator(&app.renderer, atom, &wallet_layer, "wallet_balance_separator", &mut y).await;
+    create_separator(&app.renderer, atom, &main_layer, "wallet_balance_separator", &mut y).await;
 
     // Receive button bg
-    let node = create_vector_art("wallet_receive_btn_bg");
+    let node = create_vector_art("receive_btn_bg");
     let prop = node.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, PADDING_X).unwrap();
     prop.set_f32(atom, Role::App, 1, y + PADDING_X).unwrap();
@@ -171,10 +173,10 @@ pub async fn make_main_wallet_layer(
         COLOR_TEAL,
     );
     let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     // Receive button click handler
-    let node = create_button("wallet_receive_btn");
+    let node = create_button("receive_btn");
     node.set_property_bool(atom, Role::App, "is_active", true).unwrap();
     let prop = node.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, PADDING_X).unwrap();
@@ -184,16 +186,16 @@ pub async fn make_main_wallet_layer(
     prop.set_f32(atom, Role::App, 3, BUTTON_HEIGHT).unwrap();
 
     let renderer = app.renderer.clone();
-    let wallet_is_visible2 = wallet_is_visible.clone();
+    let main_is_visible2 = main_is_visible.clone();
     let sg_root = app.sg_root.clone();
     let (slot, recvr) = Slot::new("receive_clicked");
     node.register("click", slot).unwrap();
     let listen_click = app.ex.spawn(async move {
         while recvr.recv().await.is_ok() {
             let atom = &mut renderer.make_guard(gfxtag!("receive button click"));
-            wallet_is_visible2.set(atom, false);
+            main_is_visible2.set(atom, false);
 
-            let receive_layer = sg_root.lookup_node("/window/content/wallet_receive_layer").unwrap();
+            let receive_layer = sg_root.lookup_node("/window/content/wallet/receive_layer").unwrap();
             receive_layer.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
 
             // Get the default address from drk plugin and update the UI
@@ -219,10 +221,10 @@ pub async fn make_main_wallet_layer(
     app.tasks.lock().unwrap().push(listen_click);
 
     let node = node.setup(|me| Button::new(me, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     // Receive label
-    let node = create_text("wallet_receive_label");
+    let node = create_text("receive_label");
     let prop = node.get_property("rect").unwrap();
     let code = cc.compile("PADDING_X + (w / 2 - PADDING_X * 1.5) / 2 - (BUTTON_FONTSIZE * 0.6 * 7) / 2").unwrap();
     prop.set_expr(atom, Role::App, 0, code).unwrap();
@@ -248,7 +250,7 @@ pub async fn make_main_wallet_layer(
     let node = node
         .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     // Send button bg
     let node = create_vector_art("wallet_send_btn_bg");
@@ -270,7 +272,7 @@ pub async fn make_main_wallet_layer(
         COLOR_TEAL,
     );
     let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     // Send button click handler
     let node = create_button("wallet_send_btn");
@@ -285,21 +287,21 @@ pub async fn make_main_wallet_layer(
 
     let renderer = app.renderer.clone();
     let sg_root = app.sg_root.clone();
-    let wallet_is_visible3 = wallet_is_visible.clone();
+    let main_is_visible3 = main_is_visible.clone();
     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 {
             let atom = &mut renderer.make_guard(gfxtag!("send button click"));
-            wallet_is_visible3.set(atom, false);
-            let send_layer = sg_root.lookup_node("/window/content/wallet_send_step1_layer").unwrap();
+            main_is_visible3.set(atom, false);
+            let send_layer = sg_root.lookup_node("/window/content/wallet/send_step1_layer").unwrap();
             send_layer.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
         }
     });
     app.tasks.lock().unwrap().push(listen_click);
 
     let node = node.setup(|me| Button::new(me, app.renderer.clone())).await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     // Send label
     let node = create_text("wallet_send_label");
@@ -328,13 +330,13 @@ pub async fn make_main_wallet_layer(
     let node = node
         .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
-    wallet_layer.link(node);
+    main_layer.link(node);
 
     y += PADDING_X * 2. + BUTTON_HEIGHT + 1.;
 
-    create_separator(&app.renderer, atom, &wallet_layer, "wallet_buttons_separator", &mut y).await;
+    create_separator(&app.renderer, atom, &main_layer, "wallet_buttons_separator", &mut y).await;
 
-    create_title(app, atom, &wallet_layer, &window_scale, i18n_fish, "TOKENS", &mut y).await;
+    create_title(app, atom, &main_layer, &window_scale, i18n_fish, "TOKENS", &mut y).await;
 
     let mut cc = expr::Compiler::new();
     cc.add_const_f32("PADDING_X", PADDING_X);
@@ -376,9 +378,9 @@ pub async fn make_main_wallet_layer(
     let tokens_table = tokens_table
         .setup(|me| TokenTable::new(me, app.renderer.clone(), app.sg_root.clone()))
         .await;
-    wallet_layer.link(tokens_table.clone());
+    main_layer.link(tokens_table.clone());
 
-    let wallet_layer = wallet_layer.clone();
+    let wallet_layer = main_layer.clone();
     let wallet_is_visible2 = wallet_is_visible.clone();
     let tokens_table2 = tokens_table.clone();
     let sg_root2 = app.sg_root.clone();
@@ -413,7 +415,7 @@ pub async fn make_main_wallet_layer(
                             // Update main wallet balance
                             use darkfi_money_contract::model::DARK_TOKEN_ID;
                             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") {
+                                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();
                                 }
                             }

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

@@ -31,10 +31,12 @@ pub mod send_step4;
 pub mod tx_status;
 
 use crate::{
-    app::App,
+    app::{App, node::create_layer},
+    expr,
     gfx::gfxtag,
     prop::{PropertyAtomicGuard, PropertyFloat32, Role},
     scene::SceneNodePtr,
+    ui::Layer,
     util::i18n::I18nBabelFish,
 };
 
@@ -51,13 +53,24 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     )
     .unwrap();
 
+    let atom = &mut PropertyAtomicGuard::none();
+    let wallet_layer = create_layer("wallet");
+    let prop = wallet_layer.get_property("rect").unwrap();
+    prop.set_f32(atom, Role::App, 0, 0.).unwrap();
+    prop.set_f32(atom, Role::App, 1, 0.).unwrap();
+    prop.set_expr(atom, Role::App, 2, expr::load_var("w")).unwrap();
+    prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
+    wallet_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
+    wallet_layer.set_property_u32(atom, Role::App, "z_index", 19).unwrap();
+    let wallet_layer = wallet_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
+    content.link(wallet_layer.clone());
+
     // Create main wallet layer
-    let wallet_layer = make_main_wallet_layer(app, content.clone(), i18n_fish, window_scale.clone()).await;
+    let _ = make_main_wallet_layer(app, wallet_layer.clone(), i18n_fish, window_scale.clone()).await;
 
     // Create receive layer
     let _ = make_receive_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -66,7 +79,6 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     // Create send layer
     let _ = make_send_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),

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

@@ -36,7 +36,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_receive_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -47,8 +46,10 @@ pub async fn make_receive_layer(
     cc.add_const_f32("PADDING_Y", PADDING_Y);
     cc.add_const_f32("COPY_WIDTH", COPY_WIDTH);
 
+    let main_layer = wallet_layer.lookup_node("/main_layer").unwrap();
+
     // Receive layer
-    let receive_layer = create_layer("wallet_receive_layer");
+    let receive_layer = create_layer("receive_layer");
     let prop = receive_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
@@ -57,7 +58,7 @@ pub async fn make_receive_layer(
     receive_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     receive_layer.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let receive_layer = receive_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(receive_layer.clone());
+    wallet_layer.link(receive_layer.clone());
 
     create_bg_mesh(app, atom, &receive_layer, "receive_bg").await;
     create_header_bg(app, atom, &receive_layer, "receive_header_bg").await;
@@ -84,7 +85,7 @@ pub async fn make_receive_layer(
     prop.set_f32(atom, Role::App, 2, WALLET_BTN_SIZE * 2.).unwrap();
     prop.set_f32(atom, Role::App, 3, HEADER_HEIGHT).unwrap();
 
-    let wallet_is_visible = PropertyBool::wrap(&wallet_layer, Role::App, "is_visible", 0).unwrap();
+    let main_is_visible = PropertyBool::wrap(&main_layer, Role::App, "is_visible", 0).unwrap();
     let receive_is_visible = PropertyBool::wrap(&receive_layer, Role::App, "is_visible", 0).unwrap();
     let renderer = app.renderer.clone();
     let (slot, recvr) = Slot::new("receive_back_clicked");
@@ -93,7 +94,7 @@ pub async fn make_receive_layer(
         while let Ok(_) = recvr.recv().await {
             let atom = &mut renderer.make_guard(gfxtag!("receive back button"));
             receive_is_visible.set(atom, false);
-            wallet_is_visible.set(atom, true);
+            main_is_visible.set(atom, true);
         }
     });
     app.tasks.lock().unwrap().push(listen_click);

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

@@ -33,7 +33,6 @@ use super::{data::SendTxData, data::BALANCE_BASE10_DECIMALS, send_step1::*, send
 
 pub async fn make_send_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -42,7 +41,6 @@ pub async fn make_send_layer(
 
     let send_step1_layer = make_send_step1_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -53,7 +51,6 @@ pub async fn make_send_layer(
 
     let send_step2_layer = make_send_step2_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -65,7 +62,6 @@ pub async fn make_send_layer(
 
     let send_step3_layer = make_send_step3_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -78,7 +74,6 @@ pub async fn make_send_layer(
 
     let send_step4_layer = make_send_step4_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -92,7 +87,6 @@ pub async fn make_send_layer(
 
     let tx_status_layer = make_tx_status_layer(
         app,
-        content.clone(),
         wallet_layer.clone(),
         i18n_fish,
         window_scale.clone(),
@@ -121,7 +115,7 @@ pub async fn make_send_layer(
             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_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();
@@ -129,22 +123,22 @@ pub async fn make_send_layer(
                 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_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_send_btn_bg") {
                 send_bg_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
 
             // Show transaction fee
-            if let Some(tx_fee_label) = sg_root_for_built.lookup_node("/window/content/wallet_send_step4_layer/send_fee_label") {
+            if let Some(tx_fee_label) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_fee_label") {
                 let prop = tx_fee_label.get_property("text_color").unwrap();
                 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();
             }
-            if let Some(tx_fee_value) = sg_root_for_built.lookup_node("/window/content/wallet_send_step4_layer/send_fee_value") {
+            if let Some(tx_fee_value) = sg_root_for_built.lookup_node("/window/content/wallet/send_step4_layer/send_fee_value") {
                 tx_fee_value.set_property_str(atom, Role::App, "text", encode_base10(fees, BALANCE_BASE10_DECIMALS)).unwrap();
                 let prop = tx_fee_value.get_property("text_color").unwrap();
                 prop.set_f32(atom, Role::App, 0, 1.).unwrap();
@@ -161,7 +155,7 @@ pub async fn make_send_layer(
     let step2_is_visible_sub = step2_is_visible.prop().subscribe_modify();
     let listen_step2_visible = app.ex.spawn(async move {
         while let Ok(_) = step2_is_visible_sub.receive().await {
-            let recipient_input_node = sg_root_for_focus.lookup_node("/window/content/wallet_send_step2_layer/send_recipient_input").unwrap();
+            let recipient_input_node = sg_root_for_focus.lookup_node("/window/content/wallet/send_step2_layer/send_recipient_input").unwrap();
             if step2_is_visible_for_focus.get() {
                 // Focus when becoming visible
                 loop {

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

@@ -41,7 +41,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_send_step1_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -61,10 +60,12 @@ pub async fn make_send_step1_layer(
     cc.add_const_f32("RECIPIENT_INPUT_MARGIN", RECIPIENT_INPUT_MARGIN);
     cc.add_const_f32("RECIPIENT_INPUT_PADDING_X", RECIPIENT_INPUT_PADDING_X);
 
+    let main_layer = wallet_layer.lookup_node("/main_layer").unwrap();
+
     // ============================================
     // Step 1: Pick token layer
     // ============================================
-    let send_step1_layer = create_layer("wallet_send_step1_layer");
+    let send_step1_layer = create_layer("send_step1_layer");
     let prop = send_step1_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
@@ -73,7 +74,7 @@ pub async fn make_send_step1_layer(
     send_step1_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     send_step1_layer.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let send_step1_layer = send_step1_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(send_step1_layer.clone());
+    wallet_layer.link(send_step1_layer.clone());
     let step1_is_visible = PropertyBool::wrap(&send_step1_layer, Role::App, "is_visible", 0).unwrap();
 
     create_bg_mesh(app, atom, &send_step1_layer, "send_bg").await;
@@ -101,16 +102,16 @@ pub async fn make_send_step1_layer(
     prop.set_f32(atom, Role::App, 2, WALLET_BTN_SIZE * 2.).unwrap();
     prop.set_f32(atom, Role::App, 3, HEADER_HEIGHT).unwrap();
 
-    let wallet_is_visible = PropertyBool::wrap(&wallet_layer, Role::App, "is_visible", 0).unwrap();
+    let main_is_visible = PropertyBool::wrap(&main_layer, Role::App, "is_visible", 0).unwrap();
     let renderer = app.renderer.clone();
-    let wallet_is_visible1 = wallet_is_visible.clone();
+    let main_is_visible1 = main_is_visible.clone();
     let step1_is_visible1 = step1_is_visible.clone();
     let (slot, recvr) = Slot::new("send_back_clicked");
     node.register("click", slot).unwrap();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             let atom = &mut renderer.make_guard(gfxtag!("send back button"));
-            wallet_is_visible1.set(atom, true);
+            main_is_visible1.set(atom, true);
             step1_is_visible1.set(atom, false);
         }
     });
@@ -178,12 +179,12 @@ pub async fn make_send_step1_layer(
                 drop(data);
 
                 let atom = &mut renderer.make_guard(gfxtag!("token selection"));
-                if let Some(selected_token_symbol) = sg_root.lookup_node("/window/content/wallet_send_step2_layer/send_selected_token_symbol") {
+                if let Some(selected_token_symbol) = sg_root.lookup_node("/window/content/wallet/send_step2_layer/send_selected_token_symbol") {
                     selected_token_symbol.set_property_str(atom, Role::App, "text", &row.symbol).unwrap();
                 }
 
                 step1_is_visible3.set(atom, false);
-                if let Some(step2) = sg_root.lookup_node("/window/content/wallet_send_step2_layer") {
+                if let Some(step2) = sg_root.lookup_node("/window/content/wallet/send_step2_layer") {
                     step2.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
                 }
             }
@@ -224,7 +225,7 @@ pub async fn make_send_step1_layer(
 
                             // 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") {
+                                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();
                                 }
                             }

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

@@ -40,7 +40,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_send_step2_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -64,7 +63,7 @@ pub async fn make_send_step2_layer(
     // ============================================
     // Step 2: Recipient layer
     // ============================================
-    let send_step2_layer = create_layer("wallet_send_step2_layer");
+    let send_step2_layer = create_layer("send_step2_layer");
     let prop = send_step2_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
@@ -73,10 +72,10 @@ pub async fn make_send_step2_layer(
     send_step2_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     send_step2_layer.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let send_step2_layer = send_step2_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(send_step2_layer.clone());
+    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")
+    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;
@@ -386,27 +385,27 @@ pub async fn make_send_step2_layer(
 
             // Update step3
             if let Some(token_symbol) = &data.token_symbol {
-                let token_symbol_node = sg_root.lookup_node("/window/content/wallet_send_step3_layer/send_selected_token_symbol3").unwrap();
+                let token_symbol_node = sg_root.lookup_node("/window/content/wallet/send_step3_layer/send_selected_token_symbol3").unwrap();
                 token_symbol_node.set_property_str(atom, Role::App, "text", token_symbol).unwrap();
 
                 // Update amount token symbol
-                if let Some(amount_token_node) = sg_root.lookup_node("/window/content/wallet_send_step3_layer/send_amount_token_symbol") {
+                if let Some(amount_token_node) = sg_root.lookup_node("/window/content/wallet/send_step3_layer/send_amount_token_symbol") {
                     amount_token_node.set_property_str(atom, Role::App, "text", token_symbol).unwrap();
 
                     // 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") {
+                    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 {
-                let recipient_node = sg_root.lookup_node("/window/content/wallet_send_step3_layer/send_recipient_value3").unwrap();
+                let recipient_node = sg_root.lookup_node("/window/content/wallet/send_step3_layer/send_recipient_value3").unwrap();
                 recipient_node.set_property_str(atom, Role::App, "text", recipient_str).unwrap();
             }
 
             step2_is_visible2.set(atom, false);
-            if let Some(step3) = sg_root.lookup_node("/window/content/wallet_send_step3_layer") {
+            if let Some(step3) = sg_root.lookup_node("/window/content/wallet/send_step3_layer") {
                 step3.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
         }

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

@@ -41,7 +41,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_send_step3_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -66,7 +65,7 @@ pub async fn make_send_step3_layer(
     // ============================================
     // Step 3: Amount layer
     // ============================================
-    let send_step3_layer = create_layer("wallet_send_step3_layer");
+    let send_step3_layer = create_layer("send_step3_layer");
     let prop = send_step3_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
@@ -75,10 +74,10 @@ pub async fn make_send_step3_layer(
     send_step3_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     send_step3_layer.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let send_step3_layer = send_step3_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(send_step3_layer.clone());
+    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")
+    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;
@@ -592,25 +591,25 @@ pub async fn make_send_step3_layer(
                 data.amount = Some(text.clone());
 
                 // 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") {
+                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();
                 }
-                if let Some(amount_token_node) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_amount_token_symbol4") {
+                if let Some(amount_token_node) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_amount_token_symbol4") {
                     amount_token_node.set_property_str(atom, Role::App, "text", &data.token_symbol.clone().unwrap()).unwrap();
                 }
-                if let Some(recipient_node) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_recipient_value4") {
+                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();
                 }
-                if let Some(amount_node) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_amount_wrapper4/send_amount_text4") {
+                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();
                 }
 
                 // Switch to step4 and set send button to "building tx..."
                 step3_is_visible2.set(atom, false);
-                if let Some(step4) = sg_root.lookup_node("/window/content/wallet_send_step4_layer") {
+                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_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();
@@ -618,10 +617,10 @@ pub async fn make_send_step3_layer(
                     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_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_send_btn_bg") {
                     send_bg_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
                 }
 

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

@@ -39,7 +39,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_send_step4_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -65,7 +64,7 @@ pub async fn make_send_step4_layer(
     // ============================================
     // Step 4: Confirmation layer content
     // ============================================
-    let send_step4_layer = create_layer("wallet_send_step4_layer");
+    let send_step4_layer = create_layer("send_step4_layer");
     let prop = send_step4_layer.get_property("rect").unwrap();
     prop.set_f32(atom, Role::App, 0, 0.).unwrap();
     prop.set_f32(atom, Role::App, 1, 0.).unwrap();
@@ -74,10 +73,10 @@ pub async fn make_send_step4_layer(
     send_step4_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     send_step4_layer.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let send_step4_layer = send_step4_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(send_step4_layer.clone());
+    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")
+    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;
@@ -403,7 +402,7 @@ pub async fn make_send_step4_layer(
     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_send_btn_bg") {
                 if !btn_node.get_property_bool("is_visible").unwrap() {
                     continue;
                 }
@@ -411,7 +410,7 @@ pub async fn make_send_step4_layer(
             let atom = &mut renderer.make_guard(gfxtag!("send button"));
 
             step4_is_visible1.set(atom, false);
-            if let Some(tx_status) = sg_root.lookup_node("/window/content/wallet_tx_status_layer") {
+            if let Some(tx_status) = sg_root.lookup_node("/window/content/wallet/tx_status_layer") {
                 tx_status.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
 
@@ -429,7 +428,7 @@ pub async fn make_send_step4_layer(
                         if let Ok(Some(data)) = drk_node.call_method("get_tx_status", tx_id_data).await {
                             let mut cur = std::io::Cursor::new(data);
                             if let Ok(status_text) = String::decode(&mut cur) {
-                                if let Some(tx_status) = sg_root.lookup_node("/window/content/wallet_tx_status_layer/status") {
+                                if let Some(tx_status) = sg_root.lookup_node("/window/content/wallet/tx_status_layer/status") {
                                     tx_status.set_property_str(atom, Role::App, "text", status_text).unwrap();
                                 }
                             }
@@ -483,18 +482,18 @@ pub async fn make_send_step4_layer(
 
                 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_send_btn_label") {
                         send_label_node.set_property_str(atom, Role::App, "text", "send").unwrap();
                     }
                     // Show transaction fee
-                    if let Some(tx_fee_label) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_fee_label") {
+                    if let Some(tx_fee_label) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_fee_label") {
                         let prop = tx_fee_label.get_property("text_color").unwrap();
                         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();
                     }
-                    if let Some(tx_fee_value) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_fee_value") {
+                    if let Some(tx_fee_value) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_fee_value") {
                         let prop = tx_fee_value.get_property("text_color").unwrap();
                         prop.set_f32(atom, Role::App, 0, 1.).unwrap();
                         prop.set_f32(atom, Role::App, 1, 1.).unwrap();
@@ -503,14 +502,14 @@ pub async fn make_send_step4_layer(
                     }
                 } else {
                     // Hide transaction fee
-                    if let Some(tx_fee_label) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_fee_label") {
+                    if let Some(tx_fee_label) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_fee_label") {
                         let prop = tx_fee_label.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();
                     }
-                    if let Some(tx_fee_value) = sg_root.lookup_node("/window/content/wallet_send_step4_layer/send_fee_value") {
+                    if let Some(tx_fee_value) = sg_root.lookup_node("/window/content/wallet/send_step4_layer/send_fee_value") {
                         let prop = tx_fee_value.get_property("text_color").unwrap();
                         prop.set_f32(atom, Role::App, 0, 0.).unwrap();
                         prop.set_f32(atom, Role::App, 1, 0.).unwrap();

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

@@ -39,7 +39,6 @@ use super::{super::ColorScheme, data::*, util::*};
 
 pub async fn make_tx_status_layer(
     app: &App,
-    content: SceneNodePtr,
     wallet_layer: SceneNodePtr,
     i18n_fish: &I18nBabelFish,
     window_scale: PropertyFloat32,
@@ -61,10 +60,12 @@ pub async fn make_tx_status_layer(
     cc.add_const_f32("RECIPIENT_INPUT_MARGIN", RECIPIENT_INPUT_MARGIN);
     cc.add_const_f32("RECIPIENT_INPUT_PADDING_X", RECIPIENT_INPUT_PADDING_X);
 
+    let main_layer = wallet_layer.lookup_node("/main_layer").unwrap();
+
     // ============================================
     // Transaction status layer
     // ============================================
-    let mut tx_status_layer = create_layer("wallet_tx_status_layer");
+    let mut tx_status_layer = create_layer("tx_status_layer");
 
     // Add methods for plugin calls
     tx_status_layer
@@ -102,7 +103,7 @@ pub async fn make_tx_status_layer(
     tx_status_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     tx_status_layer.set_property_u32(atom, Role::App, "z_index", 3).unwrap();
     let tx_status_layer = tx_status_layer.setup(|me| Layer::new(me, app.renderer.clone())).await;
-    content.link(tx_status_layer.clone());
+    wallet_layer.link(tx_status_layer.clone());
     let tx_status_is_visible = PropertyBool::wrap(&tx_status_layer, Role::App, "is_visible", 0).unwrap();
 
     create_bg_mesh(app, atom, &tx_status_layer, "tx_status_bg").await;
@@ -225,7 +226,7 @@ pub async fn make_tx_status_layer(
         i18n_fish,
     ).await;
 
-    let wallet_is_visible = PropertyBool::wrap(&wallet_layer, Role::App, "is_visible", 0).unwrap();
+    let main_is_visible = PropertyBool::wrap(&main_layer, Role::App, "is_visible", 0).unwrap();
     let renderer = app.renderer.clone();
     let tx_status_is_visible1 = tx_status_is_visible.clone();
     let send_tx_data2 = send_tx_data.clone();
@@ -235,7 +236,7 @@ pub async fn make_tx_status_layer(
         while let Ok(_) = recvr.recv().await {
             let atom = &mut renderer.make_guard(gfxtag!("tx status close button"));
             tx_status_is_visible1.set(atom, false);
-            wallet_is_visible.set(atom, true);
+            main_is_visible.set(atom, true);
 
             // Reset send_tx_data
             *send_tx_data2.lock().unwrap() = SendTxData::new();
@@ -269,14 +270,14 @@ pub async fn make_tx_status_layer(
 
             // Update status text
             if let Some(text) = status_text {
-                if let Some(status_node) = sg_root.lookup_node("/window/content/wallet_tx_status_layer/status") {
+                if let Some(status_node) = sg_root.lookup_node("/window/content/wallet/tx_status_layer/status") {
                     status_node.set_property_str(atom, Role::App, "text", &text).unwrap();
                 }
             }
 
             // Update transaction info display
             if let (Some(amount), Some(token_symbol), Some(recipient_str)) = (amount, token_symbol, recipient_str) {
-                if let Some(tx_info) = sg_root.lookup_node("/window/content/wallet_tx_status_layer/tx_info") {
+                if let Some(tx_info) = sg_root.lookup_node("/window/content/wallet/tx_status_layer/tx_info") {
                     let tx_text = format!("Sending {} {} to {}", amount, token_symbol, recipient_str);
                     tx_info.set_property_str(atom, Role::App, "text", tx_text).unwrap();
                 }

bin/app/src/main.rs

@@ -493,22 +493,22 @@ async fn load_plugins(
                         let _ = TokenRow::encode(row, &mut data);
                     }
 
-                    if let Some(tokens_table) = sg_root2.lookup_node("/window/content/wallet_main_layer/tokens_table") {
+                    if let Some(tokens_table) = sg_root2.lookup_node("/window/content/wallet/main_layer/tokens_table") {
                         let _ = tokens_table.call_method("set_tokens", data.clone()).await;
                     }
 
-                    if let Some(send_tokens_table) = sg_root2.lookup_node("/window/content/wallet_send_step1_layer/tokens_table") {
+                    if let Some(send_tokens_table) = sg_root2.lookup_node("/window/content/wallet/send_step1_layer/tokens_table") {
                         let _ = send_tokens_table.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") {
+                        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();
                         }
                     }
 
-                    if let Some(tx_status_layer) = sg_root2.lookup_node("/window/content/wallet_tx_status_layer") {
+                    if let Some(tx_status_layer) = sg_root2.lookup_node("/window/content/wallet/tx_status_layer") {
                         let tx_id = tx_status_layer.get_property_str("tx_id").unwrap();
                         if !tx_id.is_empty() {
                             let mut tx_id_data = vec![];
@@ -532,7 +532,7 @@ async fn load_plugins(
     let sg_root2 = sg_root.clone();
     let listen_tx = ex.spawn(async move {
         while let Ok(data) = recv.recv().await {
-            if let Some(tx_status_layer) = sg_root2.lookup_node("/window/content/wallet_tx_status_layer") {
+            if let Some(tx_status_layer) = sg_root2.lookup_node("/window/content/wallet/tx_status_layer") {
                 let _ = tx_status_layer.call_method("set_tx_status", data).await;
             }
         }
@@ -555,7 +555,7 @@ async fn load_plugins(
 
             // Update tx_status_layer with built transaction
             let atom = &mut renderer2.make_guard(gfxtag!("tx built"));
-            if let Some(tx_status) = sg_root2.lookup_node("/window/content/wallet_tx_status_layer") {
+            if let Some(tx_status) = sg_root2.lookup_node("/window/content/wallet/tx_status_layer") {
                 let mut tx_status_data = vec![];
                 None::<String>.encode(&mut tx_status_data).unwrap();
                 Some("Broadcasting transaction...".to_string()).encode(&mut tx_status_data).unwrap();
@@ -571,12 +571,12 @@ async fn load_plugins(
             }
 
             // Hide step3 layer
-            if let Some(step4_layer) = sg_root2.lookup_node("/window/content/wallet_send_step3_layer") {
+            if let Some(step4_layer) = sg_root2.lookup_node("/window/content/wallet/send_step3_layer") {
                 step4_layer.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
             }
 
             // Show step4 layer
-            if let Some(step4_layer) = sg_root2.lookup_node("/window/content/wallet_send_step4_layer") {
+            if let Some(step4_layer) = sg_root2.lookup_node("/window/content/wallet/send_step4_layer") {
                 step4_layer.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             }
         }
@@ -596,9 +596,9 @@ async fn load_plugins(
             // TODO: display error somewhere
 
             // Reset button state
-            if let Some(btn_node) = sg_root2.lookup_node("/window/content/wallet_send_step3_layer/send_amount_button") {
+            if let Some(btn_node) = sg_root2.lookup_node("/window/content/wallet/send_step3_layer/send_amount_button") {
                 btn_node.set_property_bool(atom, Role::App, "is_active", true).unwrap();
-                if let Some(label_node) = sg_root2.lookup_node("/window/content/wallet_send_step3_layer/send_amount_button_label") {
+                if let Some(label_node) = sg_root2.lookup_node("/window/content/wallet/send_step3_layer/send_amount_button_label") {
                     label_node.set_property_str(atom, Role::App, "text", "add amount").unwrap();
                 }
             }