From c05518e61c0e8cf401bbcd7ffbbe5eba8bd45969 Mon Sep 17 00:00:00 2001
From: kent-3 <100624004+kent-3@users.noreply.github.com>
Date: Sun, 20 Oct 2024 09:36:33 -0400
Subject: [PATCH] cleaning

---
 src/lib.rs                       | 123 +++++-------------
 src/routes/nav.rs                |  31 +----
 src/routes/pool.rs               |   7 +-
 src/routes/pool/add_liquidity.rs |   4 +-
 src/routes/pool/pool_creator.rs  |   1 +
 src/routes/pool/pool_manager.rs  | 215 ++++++++++---------------------
 src/state.rs                     |   2 -
 src/types/basic.rs               |   4 +-
 8 files changed, 115 insertions(+), 272 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 0e3ceaf..5c0059f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,4 @@
 #![allow(unused)]
-#![allow(mixed_script_confusables)]
-#![allow(confusable_idents)]
 
 // use codee::string::FromToStringCodec;
 // use leptos_use::storage::use_local_storage;
@@ -10,14 +8,10 @@ use leptos::{
     html::{Dialog, Input},
     logging::log,
     prelude::*,
-    reactive::graph::ReactiveNode,
 };
 use leptos_router::components::{ParentRoute, Route, Router, Routes, A};
 use leptos_router_macro::path;
-use rsecret::{
-    query::{bank::BankQuerier, compute::ComputeQuerier},
-    secret_client::CreateQuerierOptions,
-};
+use rsecret::query::{bank::BankQuerier, compute::ComputeQuerier};
 use secret_toolkit_snip20::{QueryMsg, TokenInfoResponse};
 use secretrs::utils::EnigmaUtils;
 use send_wrapper::SendWrapper;
@@ -41,7 +35,7 @@ use constants::{CHAIN_ID, GRPC_URL};
 use error::Error;
 use keplr::{Keplr, Key};
 use routes::{pool::*, trade::*};
-use state::{ChainId, Endpoint, KeplrSignals, ProviderConfig, TokenMap};
+use state::{ChainId, Endpoint, KeplrSignals, TokenMap};
 use types::Coin;
 
 #[component]
@@ -50,14 +44,11 @@ pub fn App() -> impl IntoView {
 
     // Global Contexts
 
-    // provide_context(RwSignal::new(ProviderConfig::new(GRPC_URL, CHAIN_ID)));
     provide_context(Endpoint::default());
     provide_context(ChainId::default());
     provide_context(KeplrSignals::new());
     provide_context(TokenMap::new());
 
-    // let provider =
-    //     use_context::<RwSignal<ProviderConfig>>().expect("provider config context missing!");
     let endpoint = use_context::<Endpoint>().expect("endpoint context missing!");
     let chain_id = use_context::<ChainId>().expect("chain id context missing!");
     let keplr = use_context::<KeplrSignals>().expect("keplr signals context missing!");
@@ -65,13 +56,6 @@ pub fn App() -> impl IntoView {
 
     debug!("Loaded {} tokens", token_map.len());
 
-    // Effect::new(move |_| {
-    //     let provider = provider.get();
-    //     debug!(
-    //         "Endpoint: {}\nChain ID: {}",
-    //         provider.url, provider.chain_id
-    //     )
-    // });
     Effect::new(move |_| {
         let enabled = keplr.enabled.get();
         let key = keplr.key.get();
@@ -90,10 +74,10 @@ pub fn App() -> impl IntoView {
             keplr.enabled.set(true);
         });
 
-    // let update_grpc_url = move |_| {
-    //     debug!("updating client_options.grpc_url");
-    //     wasm_client.set(Client::new("https://foobar.com".to_string()))
-    // };
+    on_cleanup(move || {
+        info!("cleaning up <App/>");
+        keplr_keystorechange_handle.remove()
+    });
 
     // Actions
 
@@ -127,38 +111,19 @@ pub fn App() -> impl IntoView {
 
     // on:click handlers
 
-    let enable_keplr = move |_| {
+    let enable_keplr = move |_: MouseEvent| {
         enable_keplr_action.dispatch(());
     };
 
-    // let disable_keplr = move |_| {
-    //     keplr_sys::disable(CHAIN_ID);
-    //     keplr.enabled.set(false);
-    //     keplr.key.set(None);
-    // };
+    let disable_keplr = move |_: MouseEvent| {
+        Keplr::disable(CHAIN_ID);
+        keplr.enabled.set(false);
+    };
 
     // Node references
 
     let options_dialog_ref = NodeRef::<Dialog>::new();
 
-    // Effects
-
-    // open the dialog whenever the "enable_keplr_action" is pending
-    // Effect::new(move |_| match dialog_ref.get() {
-    //     Some(dialog) => match enable_keplr_action.pending().get() {
-    //         true => {
-    //             let _ = dialog.show_modal();
-    //         }
-    //         false => dialog.close(),
-    //     },
-    //     None => (),
-    // });
-
-    Owner::on_cleanup(move || {
-        info!("cleaning up <Aoo/>");
-        keplr_keystorechange_handle.remove()
-    });
-
     // HTML Elements
 
     let toggle_options_menu = move |_| match options_dialog_ref.get() {
@@ -180,7 +145,6 @@ pub fn App() -> impl IntoView {
             <div class="background-image"></div>
             <header>
                 <div class="flex justify-between items-center">
-                    // <span class="italic font-extrabold">ρ</span>
                     <div class="my-3 font-bold text-3xl line-clamp-1">"Trader Crow 2"</div>
                     <Show when=move || keplr.key.get().and_then(|key| key.ok()).is_some()>
                         <p class="hidden sm:block text-sm outline outline-2 outline-offset-8 outline-neutral-500">
@@ -338,27 +302,6 @@ fn Home() -> impl IntoView {
     let keplr = use_context::<KeplrSignals>().expect("keplr signals context missing!");
     let token_map = use_context::<TokenMap>().expect("tokens context missing!");
 
-    // whenever the key store changes, this will re-set 'is_keplr_enabled' to true, triggering a
-    // reload of everything subscribed to that signal
-    let keplr_keystorechange_handle =
-        window_event_listener_untyped("keplr_keystorechange", move |_| {
-            keplr.enabled.set(true);
-        });
-
-    on_cleanup(move || {
-        info!("cleaning up <Home/>");
-        keplr_keystorechange_handle.remove()
-    });
-
-    // Effect::new(move |_| {
-    //     if keplr.enabled.get() {
-    //         spawn_local(async move {
-    //             let key: Option<Key> = Keplr::get_key(CHAIN_ID).await.ok();
-    //             keplr.key.set(key);
-    //         })
-    //     }
-    // });
-
     let viewing_keys = Resource::new(
         move || keplr.key.track(),
         move |_| {
@@ -380,6 +323,7 @@ fn Home() -> impl IntoView {
                             ));
                         }
                     }
+                    debug!("Found {} viewing keys.", keys.len());
                     keys
                 } else {
                     vec![]
@@ -408,29 +352,25 @@ fn Home() -> impl IntoView {
         })
     };
 
-    let user_balance = AsyncDerived::new_unsync(move || {
-        let client = Client::new(endpoint.get());
-        async move {
-            if let Some(Ok(key)) = keplr.key.get() {
+    let user_balance = Resource::new(
+        move || keplr.key.track(),
+        move |_| {
+            let client = Client::new(endpoint.get());
+            SendWrapper::new(async move {
                 let bank = BankQuerier::new(client);
-                match bank.balance(key.bech32_address, "uscrt").await {
-                    Ok(balance) => {
-                        let balance: Coin = balance.balance.unwrap().into();
-                        Ok(balance.to_string())
-                    }
-                    // TODO: do better with these Error semantics
-                    Err(error) => {
-                        error!("{error}");
-                        Err(Error::from(error))
-                    }
-                }
-            } else {
-                Err(Error::generic("no wallet key found"))
-            }
-        }
-    });
+                let key = keplr.key.await?;
 
-    let encryption_utils = EnigmaUtils::new(None, "secret-4").unwrap();
+                bank.balance(key.bech32_address, "uscrt")
+                    .await
+                    .map(|balance| Coin::from(balance.balance.unwrap()))
+                    .map_err(Error::from)
+                    .inspect(|coin| debug!("{coin:?}"))
+                    .inspect_err(|err| error!("{err:?}"))
+            })
+        },
+    );
+
+    let enigma_utils = EnigmaUtils::new(None, "secret-4").unwrap();
 
     // TODO: move all static resources like this (query response is always the same) to a separate
     // module. Implement caching with local storage. They can all use a random account for the
@@ -442,7 +382,7 @@ fn Home() -> impl IntoView {
         move |_| {
             debug!("loading token_info resource");
             let compute =
-                ComputeQuerier::new(Client::new(endpoint.get()), encryption_utils.clone().into());
+                ComputeQuerier::new(Client::new(endpoint.get()), enigma_utils.clone().into());
             SendWrapper::new(async move {
                 let query = QueryMsg::TokenInfo {};
                 compute
@@ -524,9 +464,6 @@ fn Modal() -> impl IntoView {
         log!("show modal");
         let node = dialog_ref.get().unwrap();
         node.show_modal().expect("I don't know what I expected");
-
-        // Example using context
-        // ctx.keplr_enabled.update(|value| *value = !*value);
     };
     let close_modal = move |_| {
         log!("close modal");
diff --git a/src/routes/nav.rs b/src/routes/nav.rs
index aee41f0..525b571 100644
--- a/src/routes/nav.rs
+++ b/src/routes/nav.rs
@@ -4,31 +4,12 @@ use leptos_router::components::A;
 #[component]
 pub fn Nav() -> impl IntoView {
     view! {
-        <header class="header">
-            <nav class="inner">
-                <A href="/home">
-                    <strong>"HN"</strong>
-                </A>
-                <A href="/new">
-                    <strong>"New"</strong>
-                </A>
-                <A href="/show">
-                    <strong>"Show"</strong>
-                </A>
-                <A href="/ask">
-                    <strong>"Ask"</strong>
-                </A>
-                <A href="/job">
-                    <strong>"Jobs"</strong>
-                </A>
-                <a
-                    class="github"
-                    href="http://github.com/leptos-rs/leptos"
-                    target="_blank"
-                    rel="noreferrer"
-                >
-                    "Built with Leptos"
-                </a>
+        <header>
+            <nav>
+                <A href="/trader-crow-leptos/">"Home"</A>
+                <A href="/trader-crow-leptos/pool">"Pool"</A>
+                <A href="/trader-crow-leptos/trade">"Trade"</A>
+                <A href="/trader-crow-leptos/analytics">"Analytics"</A>
             </nav>
         </header>
     }
diff --git a/src/routes/pool.rs b/src/routes/pool.rs
index 780af26..d0a9afa 100644
--- a/src/routes/pool.rs
+++ b/src/routes/pool.rs
@@ -15,8 +15,9 @@ use leptos_router::nested_router::Outlet;
 use send_wrapper::SendWrapper;
 use tracing::{debug, info};
 
-use crate::liquidity_book::{constants::addrs::LB_FACTORY_CONTRACT, Querier};
-use shade_protocol::contract_interfaces::liquidity_book::lb_factory::QueryMsg;
+use crate::liquidity_book::{
+    constants::addrs::LB_FACTORY_CONTRACT, contract_interfaces::lb_factory::QueryMsg, Querier,
+};
 
 #[component]
 pub fn Pool() -> impl IntoView {
@@ -45,6 +46,8 @@ pub fn Pool() -> impl IntoView {
     }
 }
 
+// NOTE: If the Router gets complicated enough, it's possible to split it up like this:
+
 // use leptos_router::{
 //     components::{ParentRoute, Route},
 //     MatchNestedRoutes,
diff --git a/src/routes/pool/add_liquidity.rs b/src/routes/pool/add_liquidity.rs
index a2b28bc..84ab731 100644
--- a/src/routes/pool/add_liquidity.rs
+++ b/src/routes/pool/add_liquidity.rs
@@ -138,6 +138,7 @@ pub fn AddLiquidity() -> impl IntoView {
         adjusted_value.round() as u32
     }
 
+    // Might be useful to have this re-run regularly at the top-level and provide a context
     // let latest_block = Resource::new(
     //     move || endpoint.get(),
     //     move |endpoint| {
@@ -222,6 +223,7 @@ pub fn AddLiquidity() -> impl IntoView {
     };
 
     let add_liquidity_action = Action::new(move |liquidity_parameters: &LiquidityParameters| {
+        // TODO: Use the dynamic versions instead.
         // let url = endpoint.get();
         // let chain_id = chain_id.get();
         let url = GRPC_URL;
@@ -238,7 +240,7 @@ pub fn AddLiquidity() -> impl IntoView {
             let wallet = Keplr::get_offline_signer_only_amino(&chain_id);
             let enigma_utils = Keplr::get_enigma_utils(&chain_id).into();
 
-            // TODO: I guess I need to make this type use Strings instead of &str, because the
+            // TODO: I guess I need to make this type use Strings instead of &'static str, because the
             // values are not static in this application (user is able to set them to anything).
             let options = CreateTxSenderOptions {
                 url,
diff --git a/src/routes/pool/pool_creator.rs b/src/routes/pool/pool_creator.rs
index 75bbab0..e0d222b 100644
--- a/src/routes/pool/pool_creator.rs
+++ b/src/routes/pool/pool_creator.rs
@@ -14,6 +14,7 @@ pub fn PoolCreator() -> impl IntoView {
     let (bin_step, set_bin_step) = signal("100".to_string());
     let (active_price, set_active_price) = signal("1".to_string());
 
+    // TODO:
     let create_pool = move |ev: leptos::ev::SubmitEvent| {
         ev.prevent_default();
         let token_x = token_x.get();
diff --git a/src/routes/pool/pool_manager.rs b/src/routes/pool/pool_manager.rs
index 746a6e4..88578d9 100644
--- a/src/routes/pool/pool_manager.rs
+++ b/src/routes/pool/pool_manager.rs
@@ -1,20 +1,23 @@
-use crate::components::SecretQuery;
-use crate::utils::shorten_address;
 use crate::{
-    constants::{CHAIN_ID, GRPC_URL},
+    components::SecretQuery,
+    constants::{CHAIN_ID, GRPC_URL, TOKEN_MAP},
     error::Error,
-    liquidity_book::constants::addrs::{LB_FACTORY_CONTRACT, LB_PAIR_CONTRACT},
-    prelude::TOKEN_MAP,
+    liquidity_book::{
+        constants::addrs::{LB_FACTORY_CONTRACT, LB_PAIR_CONTRACT},
+        contract_interfaces::lb_pair::QueryMsg,
+        Querier,
+    },
     state::*,
+    utils::shorten_address,
 };
 use cosmwasm_std::{Addr, ContractInfo};
 use leptos::prelude::*;
 use leptos_router::hooks::{query_signal_with_options, use_location, use_navigate};
-use leptos_router::NavigateOptions;
 use leptos_router::{
     components::A,
     hooks::{use_params, use_params_map, use_query_map},
     nested_router::Outlet,
+    NavigateOptions,
 };
 use rsecret::query::compute::ComputeQuerier;
 use secretrs::utils::EnigmaUtils;
@@ -58,114 +61,30 @@ pub fn PoolManager() -> impl IntoView {
     };
     let basis_points = move || params.read().get("bps").expect("Missing bps URL param");
 
-    // not sure if possible
-    fn token_symbol_converter(address: String) -> AsyncDerived<String> {
-        AsyncDerived::new(move || {
-            let address = address.clone();
-            SendWrapper::new(async move {
-                let address = Addr::unchecked(address);
-                let code_hash =
-                    "0bbaa17a6bd4533f5dc3eae14bfd1152891edaabcc0d767f611bb70437b3a159".to_string();
-                let contract = ContractInfo { address, code_hash };
-                let name = secret_toolkit_snip20::QueryMsg::TokenInfo {}
-                    .do_query(&contract)
-                    .await
-                    .inspect(|response| trace!("{:?}", response))
-                    .and_then(|response| Ok(serde_json::from_str::<serde_json::Value>(&response)?))
-                    .map(|x| x.get("token_info").unwrap().to_owned())
-                    .map(|x| {
-                        serde_json::from_value::<secret_toolkit_snip20::TokenInfo>(x.clone())
-                            .unwrap()
-                    })
-                    .map(|x| x.symbol)
-                    .unwrap();
-
-                name
-            })
-        })
+    // TODO: no hardcoded code_hash
+    async fn token_symbol_convert(address: String) -> String {
+        let contract = ContractInfo {
+            address: Addr::unchecked(address),
+            code_hash: "0bbaa17a6bd4533f5dc3eae14bfd1152891edaabcc0d767f611bb70437b3a159"
+                .to_string(),
+        };
+        secret_toolkit_snip20::QueryMsg::TokenInfo {}
+            .do_query(&contract)
+            .await
+            .inspect(|response| trace!("{:?}", response))
+            .and_then(|response| Ok(serde_json::from_str::<serde_json::Value>(&response)?))
+            .map(|x| x.get("token_info").unwrap().to_owned())
+            .map(|x| serde_json::from_value::<secret_toolkit_snip20::TokenInfo>(x.clone()).unwrap())
+            .map(|x| x.symbol)
+            .unwrap()
     }
 
-    let token_a_symbol: AsyncDerived<String> = AsyncDerived::new(move || {
-        SendWrapper::new(async move {
-            let address = Addr::unchecked(token_a());
-            let code_hash =
-                "0bbaa17a6bd4533f5dc3eae14bfd1152891edaabcc0d767f611bb70437b3a159".to_string();
-            let contract = ContractInfo { address, code_hash };
-            let symbol = secret_toolkit_snip20::QueryMsg::TokenInfo {}
-                .do_query(&contract)
-                .await
-                .inspect(|response| trace!("{:?}", response))
-                .and_then(|response| Ok(serde_json::from_str::<serde_json::Value>(&response)?))
-                .map(|x| x.get("token_info").unwrap().to_owned())
-                .map(|x| {
-                    serde_json::from_value::<secret_toolkit_snip20::TokenInfo>(x.clone()).unwrap()
-                })
-                .map(|x| x.symbol)
-                .unwrap();
-
-            symbol
-        })
-    });
-
-    let token_b_symbol: AsyncDerived<String> = AsyncDerived::new(move || {
-        SendWrapper::new(async move {
-            let address = Addr::unchecked(token_b());
-            let code_hash =
-                "0bbaa17a6bd4533f5dc3eae14bfd1152891edaabcc0d767f611bb70437b3a159".to_string();
-            let contract = ContractInfo { address, code_hash };
-            let symbol = secret_toolkit_snip20::QueryMsg::TokenInfo {}
-                .do_query(&contract)
-                .await
-                .inspect(|response| trace!("{:?}", response))
-                .and_then(|response| Ok(serde_json::from_str::<serde_json::Value>(&response)?))
-                .map(|x| x.get("token_info").unwrap().to_owned())
-                .map(|x| serde_json::from_value::<secret_toolkit_snip20::TokenInfo>(x).unwrap())
-                .map(|x| x.symbol)
-                .unwrap();
-
-            symbol
-        })
-    });
-
-    // whenever the key store changes, this will re-set 'is_keplr_enabled' to true, triggering a
-    // reload of everything subscribed to that signal
-    let keplr_keystorechange_handle =
-        window_event_listener_untyped("keplr_keystorechange", move |_| {
-            keplr.enabled.set(true);
-        });
-
-    on_cleanup(move || {
-        info!("cleaning up <PoolManager/>");
-        keplr_keystorechange_handle.remove()
-    });
-
-    // let resource = Resource::new(
-    //     move || (token_a(), token_b(), basis_points()),
-    //     move |(token_a, token_b, basis_points)| {
-    //         SendWrapper::new(async move {
-    //             let encryption_utils = secretrs::EncryptionUtils::new(None, CHAIN_ID).unwrap();
-    //             // TODO: revisit this. url is not needed, EncryptionUtils should be a trait
-    //             let options = CreateQuerierOptions {
-    //                 url: "https://grpc.mainnet.secretsaturn.net",
-    //                 chain_id: CHAIN_ID,
-    //                 encryption_utils,
-    //             };
-    //             let compute = ComputeQuerier::new(wasm_client.get(), options);
-    //             // TODO:
-    //             let query = format!("{}, {}, {}", token_a, token_b, basis_points);
-    //             debug!("{query}");
-    //
-    //             let result = compute.address_by_label("amber-24").await;
-    //             result.map_err(Into::<crate::Error>::into)
-    //         })
-    //     },
-    // );
-    // let (pending, set_pending) = signal(false);
-
-    use crate::liquidity_book::contract_interfaces::lb_pair::QueryMsg;
-    use crate::liquidity_book::Querier;
-
-    // TODO: change contract_interfaces to not use u128 in response types.
+    let token_a_symbol =
+        AsyncDerived::new_unsync(move || async move { token_symbol_convert(token_a()).await });
+    let token_b_symbol =
+        AsyncDerived::new_unsync(move || async move { token_symbol_convert(token_b()).await });
+
+    // TODO: Change contract_interfaces to not use u128 in response types. Use Uint128 instead!
 
     #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
     pub struct ReservesResponse {
@@ -180,20 +99,19 @@ pub fn PoolManager() -> impl IntoView {
         pub bin_reserve_y: String,
     }
 
-    async fn addr_2_contract(contract_address: impl Into<String>) -> Result<ContractInfo> {
-        let contract_address = contract_address.into();
+    async fn addr_2_contract(contract_address: impl AsRef<str>) -> Result<ContractInfo, Error> {
         let client = WebWasmClient::new(GRPC_URL.to_string());
         let encryption_utils = EnigmaUtils::new(None, CHAIN_ID).unwrap();
         let compute = ComputeQuerier::new(client, encryption_utils.into());
-        let contract_info = compute
-            .code_hash_by_contract_address(contract_address.clone())
+
+        compute
+            .code_hash_by_contract_address(contract_address.as_ref())
             .await
+            .map_err(Error::from)
             .map(|code_hash| ContractInfo {
-                address: Addr::unchecked(contract_address),
+                address: Addr::unchecked(contract_address.as_ref()),
                 code_hash,
-            })?;
-
-        Ok(contract_info)
+            })
     }
 
     // TODO: Move these to a separate module. IDK if it's worth splitting up the query functions
@@ -218,8 +136,6 @@ pub fn PoolManager() -> impl IntoView {
         .and_then(|response| {
             Ok(serde_json::from_str::<lb_factory::LbPairInformationResponse>(&response)?)
         })
-        // serde_json::from_str::<lb_factory::LbPairInformationResponse>(&response)
-        //     .expect("Failed to deserialize LbPairInformationResponse!")
     }
 
     async fn query_reserves(lb_pair_contract: &ContractInfo) -> Result<ReservesResponse, Error> {
@@ -228,8 +144,6 @@ pub fn PoolManager() -> impl IntoView {
             .await
             .inspect(|response| trace!("{:?}", response))
             .and_then(|response| Ok(serde_json::from_str::<ReservesResponse>(&response)?))
-        // serde_json::from_str::<ReservesResponse>(&response)
-        //     .expect("Failed to deserialize ReservesResponse!")
     }
 
     async fn query_active_id(lb_pair_contract: &ContractInfo) -> Result<u32, Error> {
@@ -239,7 +153,6 @@ pub fn PoolManager() -> impl IntoView {
             .inspect(|response| trace!("{:?}", response))
             .and_then(|response| Ok(serde_json::from_str::<ActiveIdResponse>(&response)?))
             .map(|x| x.active_id)
-        // .expect("Failed to deserialize ActiveIdResponse!")
     }
 
     async fn query_bin_reserves(
@@ -319,11 +232,13 @@ pub fn PoolManager() -> impl IntoView {
         },
     );
 
-    // prevents scrolling to the top of the page each time a query param changes
     let nav_options = NavigateOptions {
+        // prevents scrolling to the top of the page each time a query param changes
         scroll: false,
         ..Default::default()
     };
+
+    // This component only needs to write to the signal
     let (_, set_active_id) = query_signal_with_options::<String>("active_id", nav_options.clone());
 
     let active_id = Resource::new(
@@ -333,11 +248,15 @@ pub fn PoolManager() -> impl IntoView {
                 let lb_pair_contract = lb_pair_information.await.lb_pair.contract;
                 query_active_id(&lb_pair_contract)
                     .await
+                    // This will set a URL query param "active_id" for nested routes to use
                     .inspect(|id| set_active_id.set(Some(id.to_string())))
             })
         },
     );
 
+    // NOTE: We have a lot of Resources depending on other Resources.
+    //       It works, but I wonder if there is a better way.
+
     let bin_reserves = Resource::new(
         move || (lb_pair_information.track(), active_id.track()),
         move |_| {
@@ -406,27 +325,6 @@ pub fn PoolManager() -> impl IntoView {
             </div>
         </div>
 
-        // <Suspense fallback=|| view! { <p>"Loading..."</p> }>
-        // // you can `.await` resources to avoid dealing with the `None` state
-        // <p>
-        // "User ID: "
-        // {move || Suspend::new(async move {
-        // match resource.await {
-        // Ok(response) => response,
-        // Err(_) => "error".to_string(),
-        // }
-        // })}
-        // </p>
-        // or you can still use .get() to access resources in things like component props
-        // <For
-        // each=move || resource.get().and_then(Result::ok).unwrap_or_default()
-        // key=|resource| resource.id
-        // let:post
-        // >
-        // // ...
-        // </For>
-        // </Suspense>
-
         <details class="text-neutral-300 font-bold">
             <summary class="text-lg cursor-pointer">Pool Details</summary>
             <ul class="my-1 font-normal text-base text-neutral-200 ">
@@ -479,7 +377,7 @@ pub fn PoolManager() -> impl IntoView {
         </details>
 
         <div class="flex gap-4 py-2">
-            // This works to preserve the query params when navigating to nested routes.
+            // This preserves the query params when navigating to nested routes.
             <button on:click=move |_| {
                 let pathname = location.pathname.get();
                 let query_params = location.search.get();
@@ -499,3 +397,24 @@ pub fn PoolManager() -> impl IntoView {
         <Outlet />
     }
 }
+
+// <Suspense fallback=|| view! { <p>"Loading..."</p> }>
+// // you can `.await` resources to avoid dealing with the `None` state
+// <p>
+// "User ID: "
+// {move || Suspend::new(async move {
+// match resource.await {
+// Ok(response) => response,
+// Err(_) => "error".to_string(),
+// }
+// })}
+// </p>
+// or you can still use .get() to access resources in things like component props
+// <For
+// each=move || resource.get().and_then(Result::ok).unwrap_or_default()
+// key=|resource| resource.id
+// let:post
+// >
+// // ...
+// </For>
+// </Suspense>
diff --git a/src/state.rs b/src/state.rs
index 66a9f25..38e3e40 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -4,9 +4,7 @@ use crate::{
     keplr::{tokens::ContractInfo, Keplr, Key},
 };
 use leptos::prelude::*;
-use send_wrapper::SendWrapper;
 use std::{collections::HashMap, ops::Deref};
-use tonic_web_wasm_client::Client;
 use tracing::{debug, trace};
 
 #[derive(Clone, Debug, PartialEq)]
diff --git a/src/types/basic.rs b/src/types/basic.rs
index 6a31a90..08b75c0 100644
--- a/src/types/basic.rs
+++ b/src/types/basic.rs
@@ -1,5 +1,7 @@
+use serde::{Deserialize, Serialize};
+
 // TODO: include the decimals somehow, and use that in the Display trait
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Coin {
     pub denom: String,
     pub amount: String,