diff --git a/Cargo.lock b/Cargo.lock
index 02d37a3..023aa9d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1761,19 +1761,6 @@ dependencies = [
  "sha2 0.10.8",
 ]
 
-[[package]]
-name = "keplr"
-version = "0.1.0"
-dependencies = [
- "base64 0.22.1",
- "js-sys",
- "keplr-sys",
- "serde",
- "serde-wasm-bindgen 0.6.5",
- "thiserror",
- "web-sys",
-]
-
 [[package]]
 name = "keplr-sys"
 version = "0.1.0"
@@ -2868,7 +2855,7 @@ dependencies = [
  "futures",
  "git2",
  "js-sys",
- "keplr",
+ "keplr-sys",
  "leptos",
  "leptos_meta",
  "leptos_router",
@@ -2887,6 +2874,7 @@ dependencies = [
  "tracing-subscriber-wasm",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index d6ba639..4f017e1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,6 +58,7 @@ tonic = { version = "0.11.0", default-features = false }
 # Web support
 console_error_panic_hook = "0.1.7"
 js-sys = "0.3"
+web-sys = "0.3"
 # gloo-net = "0.6"
 # gloo-storage = "0.3"
 
@@ -82,6 +83,6 @@ tracing-subscriber = "0.3"
 tracing-subscriber-wasm = "0.1"
 
 # Local
-keplr = { path = "../keplr/keplr" }
+keplr-sys = { path = "../keplr/keplr-sys" }
 rsecret = { path = "../secret-clients/rsecret" }
 secretrs = { version = "0.1" }
diff --git a/dist/index.html b/dist/index.html
index 2f122cd..4d34108 100644
--- a/dist/index.html
+++ b/dist/index.html
@@ -6,9 +6,9 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 
   
-<script type="module" nonce="7FMyFJtSxiUhB+GeBXVGzA==">
-import init, * as bindings from 'https://kent-3.github.io/secret-leptos/secret-leptos-a6c6fd9b4d31a18d.js';
-const wasm = await init('https://kent-3.github.io/secret-leptos/secret-leptos-a6c6fd9b4d31a18d_bg.wasm');
+<script type="module" nonce="mY8Yb/pms7oi6Cs+Er587g==">
+import init, * as bindings from 'https://kent-3.github.io/secret-leptos/secret-leptos-1cce32ade9d28a25.js';
+const wasm = await init('https://kent-3.github.io/secret-leptos/secret-leptos-1cce32ade9d28a25_bg.wasm');
 
 
 window.wasmBindings = bindings;
@@ -18,7 +18,7 @@
 
 </script>
   <link rel="icon" href="https://kent-3.github.io/secret-leptos/favicon-e9cbd8f50cc65bf2.ico" integrity="sha384&#x2D;YobgLXwtz0GhXVUTHml49p32guapVFlEG8UpQdDVN3kekOqkQi&#x2B;qSXEpwp&#x2B;yM4BW"/>
-  <link rel="stylesheet" href="https://kent-3.github.io/secret-leptos/input-1e281e73305a75dd.css" integrity="sha384&#x2D;oetCHYGBfUNM84kyFcBMXGp8djsTF4YBWZK4mg1yjqBxJgfjTVf&#x2B;aqfZN7&#x2B;6Tzkf"/>
+  <link rel="stylesheet" href="https://kent-3.github.io/secret-leptos/input-19d3d6031e6224f1.css" integrity="sha384&#x2D;Llf&#x2F;1z3pS30ykImra&#x2F;t6OnhoWltBvHrJog4vWANEoBZhLszMWX24fL&#x2B;f9mlg3zE3"/>
 
   <script>
     function checkResourcesLoaded() {
@@ -39,8 +39,8 @@
     });
   </script>
 
-<link rel="modulepreload" href="https://kent-3.github.io/secret-leptos/secret-leptos-a6c6fd9b4d31a18d.js" crossorigin=anonymous integrity="sha384-jRERt5wpq7c3IgcgCviHwLicEDT33Y7dITe70HpmbZjptSQga3w3ljCc7NwcysZ8">
-<link rel="preload" href="https://kent-3.github.io/secret-leptos/secret-leptos-a6c6fd9b4d31a18d_bg.wasm" crossorigin=anonymous integrity="sha384-W9KQIgECqP6qPQ4tWbUwSgCJKU12mU9U1I3L9GZgne6q6kTpzTtEHGiooHi1V754" as="fetch" type="application/wasm"></head>
+<link rel="modulepreload" href="https://kent-3.github.io/secret-leptos/secret-leptos-1cce32ade9d28a25.js" crossorigin=anonymous integrity="sha384-GXM0tQw/lzpbcp+ia4iAWuzoUTO3GLyt00CDnfhvN7dhHmkdmYZJqpbKZa/HQU8n">
+<link rel="preload" href="https://kent-3.github.io/secret-leptos/secret-leptos-1cce32ade9d28a25_bg.wasm" crossorigin=anonymous integrity="sha384-UR999BpHxsj2kA+4azjCGWHggx3PxoGAhc7Qu5YKvWf0jRuN9N49XV0mRI4PPqm4" as="fetch" type="application/wasm"></head>
 
 <style>
   .spinner {
diff --git a/dist/input-1e281e73305a75dd.css b/dist/input-19d3d6031e6224f1.css
similarity index 99%
rename from dist/input-1e281e73305a75dd.css
rename to dist/input-19d3d6031e6224f1.css
index d46c2f3..7bbec90 100644
--- a/dist/input-1e281e73305a75dd.css
+++ b/dist/input-19d3d6031e6224f1.css
@@ -205,6 +205,11 @@
   line-height: 1.75rem;
 }
 
+.text-sm {
+  font-size: 0.875rem;
+  line-height: 1.25rem;
+}
+
 .font-bold {
   font-weight: 700;
 }
diff --git a/dist/secret-leptos-a6c6fd9b4d31a18d.js b/dist/secret-leptos-1cce32ade9d28a25.js
similarity index 98%
rename from dist/secret-leptos-a6c6fd9b4d31a18d.js
rename to dist/secret-leptos-1cce32ade9d28a25.js
index f005d7f..d32116f 100644
--- a/dist/secret-leptos-a6c6fd9b4d31a18d.js
+++ b/dist/secret-leptos-1cce32ade9d28a25.js
@@ -469,16 +469,6 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_remove_81fdfdc9088ee033 = function(arg0) {
         getObject(arg0).remove();
     };
-    imports.wbg.__wbg_preventDefault_c55d86c27b2dfa6e = function(arg0) {
-        getObject(arg0).preventDefault();
-    };
-    imports.wbg.__wbg_value_d4a95e7a0d390578 = function(arg0, arg1) {
-        const ret = getObject(arg1).value;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
     imports.wbg.__wbg_getEnigmaUtils_43f42e9235e0913c = function(arg0, arg1) {
         const ret = window.keplr.getEnigmaUtils(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -493,6 +483,16 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_close_1a7c6f85879ea3c4 = function(arg0) {
         getObject(arg0).close();
     };
+    imports.wbg.__wbg_preventDefault_c55d86c27b2dfa6e = function(arg0) {
+        getObject(arg0).preventDefault();
+    };
+    imports.wbg.__wbg_value_d4a95e7a0d390578 = function(arg0, arg1) {
+        const ret = getObject(arg1).value;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg_body_b3bb488e8e54bf4b = function(arg0) {
         const ret = getObject(arg0).body;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -675,10 +675,6 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_message_e18bae0a0e2c097a = function(arg0) {
-        const ret = getObject(arg0).message;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_disable_ed6a167e9fc723b1 = function(arg0, arg1) {
         window.keplr.disable(getStringFromWasm0(arg0, arg1));
     };
@@ -838,6 +834,10 @@ function __wbg_get_imports() {
         const ret = window.keplr.getSecret20ViewingKey(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_message_e18bae0a0e2c097a = function(arg0) {
+        const ret = getObject(arg0).message;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_getKey_8255541c6425d853 = function() { return handleError(function (arg0, arg1) {
         const ret = window.keplr.getKey(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -858,6 +858,16 @@ function __wbg_get_imports() {
         const ret = getObject(arg0) in getObject(arg1);
         return ret;
     };
+    imports.wbg.__wbg_ping_cb8b34dd389cde4c = function() { return handleError(function () {
+        const ret = window.keplr.ping();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_enable_70f888566a8088b5 = function() { return handleError(function (arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_export_5(arg0, arg1 * 4, 4);
+        const ret = window.keplr.enable(v0);
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_new_525245e2b9901204 = function() {
         const ret = new Object();
         return addHeapObject(ret);
@@ -866,10 +876,6 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_enable_70f888566a8088b5 = function() { return handleError(function (arg0, arg1) {
-        const ret = window.keplr.enable(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_set_f975102236d3c502 = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
@@ -884,8 +890,8 @@ function __wbg_get_imports() {
         const ret = window.keplr.experimentalSuggestChain(takeObject(arg0));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_suggestToken_843c76cab321fd73 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-        const ret = window.keplr.suggestToken(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+    imports.wbg.__wbg_suggestToken_843c76cab321fd73 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        const ret = window.keplr.suggestToken(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5));
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_getOfflineSignerOnlyAmino_ebb2efe1afcd60b6 = function(arg0, arg1) {
@@ -900,10 +906,6 @@ function __wbg_get_imports() {
         const ret = Array.from(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_is_null = function(arg0) {
-        const ret = getObject(arg0) === null;
-        return ret;
-    };
     imports.wbg.__wbg_warn_2b3adb99ce26c314 = function(arg0) {
         console.warn(getObject(arg0));
     };
@@ -975,6 +977,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).host;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = getObject(arg0) === null;
+        return ret;
+    };
     imports.wbg.__wbg_createTextNode_8bce33cf33bf8f6e = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).createTextNode(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
@@ -1257,15 +1263,15 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_alert_c1d5ffe256491b29 = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).alert(getStringFromWasm0(arg1, arg2));
     }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper2632 = function(arg0, arg1, arg2) {
-        const ret = makeClosure(arg0, arg1, 173, __wbg_adapter_46);
+    imports.wbg.__wbindgen_closure_wrapper2627 = function(arg0, arg1, arg2) {
+        const ret = makeClosure(arg0, arg1, 170, __wbg_adapter_46);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper2638 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper2633 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 386, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper4250 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper4244 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 415, __wbg_adapter_49);
         return addHeapObject(ret);
     };
diff --git a/dist/secret-leptos-1cce32ade9d28a25_bg.wasm b/dist/secret-leptos-1cce32ade9d28a25_bg.wasm
new file mode 100644
index 0000000..7af7aa8
Binary files /dev/null and b/dist/secret-leptos-1cce32ade9d28a25_bg.wasm differ
diff --git a/dist/secret-leptos-a6c6fd9b4d31a18d_bg.wasm b/dist/secret-leptos-a6c6fd9b4d31a18d_bg.wasm
deleted file mode 100644
index db35b19..0000000
Binary files a/dist/secret-leptos-a6c6fd9b4d31a18d_bg.wasm and /dev/null differ
diff --git a/src/error.rs b/src/error.rs
index 9467762..b11ecf5 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,13 +1,15 @@
+// The Serialize and Deserialize traits are derived to ensure that Errors can be
+// transmitted to or from a server, which is necessary for them to function as Resources.
 #[derive(thiserror::Error, serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
 pub enum Error {
     #[error("An error occurred: {0}")]
-    GenericError(String),
+    Generic(String),
 
-    #[error("A Secret error occurred: {0}")]
-    SecretError(String),
+    #[error("An error related to Secret occurred: {0}")]
+    Secret(String),
 
-    #[error(transparent)]
-    KeplrError(#[from] ::keplr::Error),
+    #[error("An error related to Keplr occurred: {0}")]
+    Keplr(#[from] crate::keplr::Error),
 
     #[error("Keplr is not enabled!")]
     KeplrDisabled,
@@ -15,13 +17,13 @@ pub enum Error {
 
 impl From<rsecret::Error> for Error {
     fn from(error: rsecret::Error) -> Self {
-        Error::SecretError(error.to_string())
+        Error::Secret(error.to_string())
     }
 }
 
 impl Error {
     pub fn generic(message: impl ToString) -> Self {
         let message = message.to_string();
-        Error::GenericError(message)
+        Error::Generic(message)
     }
 }
diff --git a/src/keplr/error.rs b/src/keplr/error.rs
new file mode 100644
index 0000000..7a27e12
--- /dev/null
+++ b/src/keplr/error.rs
@@ -0,0 +1,17 @@
+#[derive(thiserror::Error, serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
+pub enum Error {
+    #[error("An error occurred in JavaScript: {0}")]
+    JsError(String),
+    // #[error("Serialization Error: {0}")]
+    // SerializationError(#[from] serde_wasm_bindgen::Error),
+}
+
+impl From<js_sys::wasm_bindgen::JsValue> for Error {
+    fn from(error: js_sys::wasm_bindgen::JsValue) -> Self {
+        let message = js_sys::Error::from(error)
+            .message()
+            .as_string()
+            .unwrap_or("unknown JS error".to_string());
+        Error::JsError(message)
+    }
+}
diff --git a/src/keplr/keplr.rs b/src/keplr/keplr.rs
new file mode 100644
index 0000000..d2f56eb
--- /dev/null
+++ b/src/keplr/keplr.rs
@@ -0,0 +1,250 @@
+use crate::keplr::Error;
+use base64::prelude::{Engine as _, BASE64_STANDARD};
+use futures::TryFutureExt;
+use js_sys::JsString;
+use keplr_sys::*;
+use serde::{Deserialize, Serialize};
+use web_sys::console;
+
+/// An Amino encoded message.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AminoMsg {
+    pub r#type: String,
+    pub value: Vec<u8>,
+}
+
+/// Response after signing with Amino.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AminoSignResponse {
+    /// The sign_doc that was signed.
+    ///
+    /// This may be different from the input sign_doc when the signer modifies it as part of the signing process.
+    pub signed: StdSignDoc,
+    pub signature: StdSignature,
+}
+
+/// Standard signature.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StdSignature {
+    #[serde(alias = "pubKey")]
+    pub pub_key: Pubkey,
+    pub signature: String,
+}
+
+/// Public key.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Pubkey {
+    /// Possible types include:
+    /// - "tendermint/PubKeySecp256k1"
+    /// - "tendermint/PubKeyEd25519"
+    /// - "tendermint/PubKeySr25519
+    pub r#type: String,
+    /// Base64 encoded String
+    pub value: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StdSignDoc {
+    pub chain_id: String,
+    pub account_number: String,
+    pub sequence: String,
+    pub fee: StdFee,
+    pub msgs: Vec<AminoMsg>,
+    pub memo: String,
+}
+
+/// Standard fee.
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct StdFee {
+    pub amount: Vec<Coin>,
+    pub gas: String,
+    pub granter: Option<String>,
+}
+
+pub type Coin = String;
+
+#[derive(Serialize, Deserialize, Clone, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct KeyInfo {
+    /// Name of the selected key store.
+    pub name: String,
+    pub algo: String,
+    pub pub_key: Vec<u8>,
+    pub address: Vec<u8>,
+    pub bech32_address: String,
+    pub ethereum_hex_address: String,
+    // Indicate whether the selected account is from the nano ledger.
+    // Because current cosmos app in the nano ledger doesn't support the direct (proto) format msgs,
+    // this can be used to select the amino or direct signer.
+    pub is_nano_ledger: bool,
+    pub is_keystone: bool,
+}
+
+impl std::fmt::Debug for KeyInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("KeyInfo")
+            .field("name", &self.name)
+            .field("algo", &self.algo)
+            .field("pub_key", &BASE64_STANDARD.encode(&self.pub_key)) // Convert pub_key to base64
+            .field("address", &BASE64_STANDARD.encode(&self.address)) // Convert address to base64
+            .field("bech32_address", &self.bech32_address)
+            .field("ethereum_hex_address", &self.ethereum_hex_address)
+            .field("is_nano_ledger", &self.is_nano_ledger)
+            .field("is_keystone", &self.is_keystone)
+            .finish()
+    }
+}
+
+pub struct Keplr {}
+
+impl Keplr {
+    pub fn debug() {
+        KEPLR.with(console::log_1)
+    }
+
+    pub async fn ping() -> Result<(), Error> {
+        ping().await.map_err(Into::into)
+    }
+
+    pub async fn enable(chain_ids: Vec<String>) -> Result<(), Error> {
+        enable(chain_ids).await.map_err(Into::into)
+    }
+
+    pub async fn get_key(chain_id: &str) -> Result<KeyInfo, Error> {
+        get_key(chain_id)
+            .await
+            .and_then(|key| Ok(serde_wasm_bindgen::from_value::<KeyInfo>(key)?))
+            .map_err(Into::into)
+    }
+
+    pub async fn get_account(chain_id: &str) -> Account {
+        let signer = get_offline_signer_only_amino(chain_id);
+        let accounts = signer.get_accounts().await;
+        let accounts = js_sys::Array::from(&accounts);
+        let account = accounts.get(0);
+
+        let account: Account = serde_wasm_bindgen::from_value(account)
+            .expect("There was a problem with deserializing the 'Account'");
+
+        account
+    }
+
+    // pub fn get_offline_signer(chain_id: &str) -> KeplrOfflineSigner {
+    //     get_offline_signer(chain_id)
+    // }
+    //
+    // pub fn get_offline_signer_only_amino(chain_id: &str) -> KeplrOfflineSigner {
+    //     get_offline_signer_only_amino(chain_id)
+    // }
+    //
+    // pub fn get_enigma_utils(chain_id: &str) -> EnigmaUtils {
+    //     EnigmaUtils::new(get_enigma_utils(chain_id))
+    // }
+
+    pub async fn suggest_token(
+        chain_id: &str,
+        contract_address: &str,
+        viewing_key: Option<&str>,
+    ) -> Result<(), Error> {
+        suggest_token(chain_id, contract_address, viewing_key)
+            .await
+            .map_err(Into::into)
+    }
+
+    pub async fn get_secret_20_viewing_key(
+        chain_id: &str,
+        contract_address: &str,
+    ) -> Result<String, Error> {
+        get_secret_20_viewing_key(chain_id, contract_address)
+            .await
+            .map(|foo| JsString::from(foo).into())
+            .map_err(Into::into)
+    }
+
+    pub fn disable(chain_id: &str) {
+        disable(chain_id)
+    }
+
+    pub fn disable_origin() {
+        disable_origin()
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct Account {
+    pub address: String,
+    pub algo: String,
+    pub pubkey: Vec<u8>,
+}
+
+impl std::fmt::Debug for Account {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Account")
+            .field("address", &self.address)
+            .field("algo", &self.algo)
+            .field("pubkey", &BASE64_STANDARD.encode(&self.pubkey)) // Convert pubkey to base64
+            .finish()
+    }
+}
+
+pub mod suggest_chain_types {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct SuggestingChainInfo {
+        pub chain_id: String,
+        pub chain_name: String,
+        pub rpc: String,
+        pub rest: String,
+        pub bip44: Bip44,
+        pub bech32_config: Bech32Config,
+        pub currencies: Vec<Currency>,
+        pub fee_currencies: Vec<FeeCurrency>,
+        pub stake_currency: Currency,
+    }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct Bip44 {
+        pub coin_type: u32,
+    }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct Bech32Config {
+        pub bech32_prefix_acc_addr: String,
+        pub bech32_prefix_acc_pub: String,
+        pub bech32_prefix_val_addr: String,
+        pub bech32_prefix_val_pub: String,
+        pub bech32_prefix_cons_addr: String,
+        pub bech32_prefix_cons_pub: String,
+    }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct Currency {
+        pub coin_denom: String,
+        pub coin_minimal_denom: String,
+        pub coin_decimals: u8,
+        pub coin_gecko_id: String,
+    }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct FeeCurrency {
+        pub coin_denom: String,
+        pub coin_minimal_denom: String,
+        pub coin_decimals: u8,
+        pub coin_gecko_id: String,
+        pub gas_price_step: GasPriceStep,
+    }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct GasPriceStep {
+        pub low: f64,
+        pub average: f64,
+        pub high: f64,
+    }
+}
diff --git a/src/keplr/mod.rs b/src/keplr/mod.rs
index 8ba19eb..d6c3ec9 100644
--- a/src/keplr/mod.rs
+++ b/src/keplr/mod.rs
@@ -1,3 +1,8 @@
+mod error;
+mod keplr;
 mod tests;
 
+pub use error::Error;
+pub use keplr::*;
+pub use keplr_sys;
 pub use tests::KeplrTests;
diff --git a/src/keplr/tests.rs b/src/keplr/tests.rs
index e1548a7..c86b5a5 100644
--- a/src/keplr/tests.rs
+++ b/src/keplr/tests.rs
@@ -1,14 +1,13 @@
+use crate::keplr::{suggest_chain_types::*, Account, Keplr, KeyInfo};
 use crate::CHAIN_ID;
-use ::keplr::keplr_sys; // normally you wouldn't use keplr_sys directly
-use ::keplr::{suggest_chain_types::*, Account, Keplr, KeyInfo};
+use keplr_sys; // normally you wouldn't use keplr_sys directly
 use leptos::prelude::*;
 use leptos::web_sys::console;
-
 use tracing::{debug, info};
 
-async fn enable_keplr(chain_id: &str) -> bool {
+async fn enable_keplr(chain_id: impl ToString) -> bool {
     debug!("Trying to enable Keplr...");
-    Keplr::enable(chain_id).await.is_ok()
+    Keplr::enable(vec![chain_id.to_string()]).await.is_ok()
 }
 
 // the "keplrOfflineSigner" object is used in the client constructor
@@ -36,7 +35,7 @@ async fn get_key(chain_id: &str) -> KeyInfo {
 }
 
 // internal use only
-fn get_enigma_utils(chain_id: &str) -> () {
+fn get_enigma_utils(chain_id: &str) {
     let js_value = keplr_sys::get_enigma_utils(chain_id);
 
     console::log_1(&js_value);
@@ -52,20 +51,14 @@ async fn get_secret_20_viewing_key(chain_id: &str, contract_address: String) ->
     key
 }
 
-async fn suggest_token(chain_id: &str, contract_address: &str) {
-    let _ = keplr_sys::suggest_token(chain_id, contract_address).await;
+async fn suggest_token(chain_id: &str, contract_address: &str, viewing_key: Option<&str>) {
+    let _ = Keplr::suggest_token(chain_id, contract_address, viewing_key).await;
 
     // if you want to handle the error case (user closes the pop up):
 
-    // let result = ::keplr::suggest_token(chain_id, contract_address)
+    // let result = Keplr::suggest_token(chain_id, contract_address, viewing_key)
     //     .await
-    //     .map_err(|js_value| {
-    //         let error = Error::from(js_value)
-    //             .message()
-    //             .as_string()
-    //             .unwrap_or("unknown error".to_string());
-    //         error
-    //     });
+    //     .map_err(Into::into);
     //
     // match result {
     //     Ok(_) => log!("token added?"),
@@ -93,13 +86,18 @@ pub fn KeplrTests() -> impl IntoView {
             get_secret_20_viewing_key(CHAIN_ID, token_address)
         });
     let suggest_token_action: Action<(), (), SyncStorage> = Action::new_unsync(move |_: &()| {
-        suggest_token(CHAIN_ID, "secret1s09x2xvfd2lp2skgzm29w2xtena7s8fq98v852")
+        suggest_token(
+            CHAIN_ID,
+            "secret1s09x2xvfd2lp2skgzm29w2xtena7s8fq98v852",
+            Some("hola"),
+        )
     });
 
     let suggest_chain_action: Action<(), (), SyncStorage> =
         Action::new_unsync(move |_: &()| suggest());
 
-    // Event Handlers
+    // on:click Handlers
+
     let enable_keplr = move |_| _ = enable_keplr_action.dispatch(());
     let get_account = move |_| _ = get_account_action.dispatch(());
     let get_key = move |_| _ = get_key_action.dispatch(());
@@ -112,11 +110,13 @@ pub fn KeplrTests() -> impl IntoView {
     let suggest_chain = move |_| _ = suggest_chain_action.dispatch_local(());
 
     // Action Value Signals
+
     let account = get_account_action.value();
     let key = get_key_action.value();
     let viewing_key = get_viewing_key_action.value();
 
     // Non-Actions
+
     let get_enigma_utils = move |_| get_enigma_utils(CHAIN_ID);
     let disable_keplr = move |_| {
         keplr_sys::disable(CHAIN_ID);
diff --git a/src/lib.rs b/src/lib.rs
index 9d9e264..e4d04dc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,7 @@
 // use codee::string::FromToStringCodec;
 // use leptos_use::storage::use_local_storage;
 
-use ::keplr::{keplr_sys, Keplr, KeyInfo};
+use keplr::{keplr_sys, Keplr, KeyInfo};
 use leptos::{
     ev::MouseEvent,
     html::{Dialog, Input},
@@ -28,8 +28,10 @@ mod components;
 mod constants;
 mod error;
 mod keplr;
+mod prelude;
 mod state;
 mod tokens;
+mod utils;
 
 use components::Spinner2;
 use constants::{CHAIN_ID, GRPC_URL};
@@ -92,6 +94,13 @@ pub enum QueryAnswer {
 pub fn App() -> impl IntoView {
     info!("rendering <App/>");
 
+    spawn_local(async {
+        match Keplr::ping().await {
+            Ok(_) => debug!("Keplr is available!"),
+            Err(_) => debug!("Keplr is not available!"),
+        }
+    });
+
     // Global Context
 
     let keplr = KeplrSignals::new();
@@ -123,17 +132,15 @@ pub fn App() -> impl IntoView {
 
     let enable_keplr_action: Action<(), bool, SyncStorage> =
         Action::new_unsync_with_value(Some(false), move |_: &()| async move {
-            let keplr_extension = js_sys::Reflect::get(&window(), &JsValue::from_str("keplr"))
-                .expect("unable to check for `keplr` property");
-
-            if keplr_extension.is_undefined() || keplr_extension.is_null() {
+            if Keplr::ping().await.is_err() {
                 window()
                     .alert_with_message("keplr not found")
                     .expect("alert failed");
+                keplr.enabled.set(false);
                 false
             } else {
                 debug!("Trying to enable Keplr...");
-                match Keplr::enable(CHAIN_ID).await {
+                match Keplr::enable(vec![CHAIN_ID.to_string()]).await {
                     Ok(_) => {
                         keplr.enabled.set(true);
                         debug!("Keplr is enabled");
@@ -184,14 +191,6 @@ pub fn App() -> impl IntoView {
 
     // HTML Elements
 
-    let connect_button = move || {
-        view! {
-            <button on:click=enable_keplr disabled=enable_keplr_action.pending()>
-                Connect Wallet
-            </button>
-        }
-    };
-
     let toggle_options_menu = move |_| match options_dialog_ref.get() {
         Some(dialog) => match dialog.open() {
             false => {
@@ -204,10 +203,6 @@ pub fn App() -> impl IntoView {
         }
     };
 
-    let options_button = move || {
-        view! { <button on:click=toggle_options_menu>"Options"</button> }
-    };
-
     let key_name = move || {
         keplr
             .key_info
@@ -223,14 +218,26 @@ pub fn App() -> impl IntoView {
                     <h1>"Secret Leptos"</h1>
                     // terrible, but it works...
                     <Show when=move || {
-                        keplr.key_info.get().and_then(|foo| Some(foo.is_ok())).unwrap_or_default()
+                        keplr.key_info.get().map(|foo| foo.is_ok()).unwrap_or_default()
                     }>
-                        <p class="outline outline-2 outline-offset-8 outline-neutral-500">
-                            Connected as <strong>{key_name}</strong>
+                        <p class="text-sm outline outline-2 outline-offset-8 outline-neutral-500">
+                            "Connected as "<strong>{key_name}</strong>
                         </p>
                     </Show>
-                    <Show when=move || keplr.enabled.get() fallback=connect_button>
-                        {options_button}
+                    <Show
+                        when=move || keplr.enabled.get()
+                        fallback=move || {
+                            view! {
+                                <button
+                                    on:click=enable_keplr
+                                    disabled=enable_keplr_action.pending()
+                                >
+                                    Connect Wallet
+                                </button>
+                            }
+                        }
+                    >
+                        <button on:click=toggle_options_menu>"Options"</button>
                     </Show>
                 </div>
                 <hr />
@@ -457,7 +464,7 @@ fn Home() -> impl IntoView {
             compute
                 .query_secret_contract(contract_address, code_hash, query)
                 .await
-                .map_err(|error| Error::generic(error))
+                .map_err(Error::generic)
         })
     });
 
diff --git a/src/prelude.rs b/src/prelude.rs
new file mode 100644
index 0000000..bd491c3
--- /dev/null
+++ b/src/prelude.rs
@@ -0,0 +1,3 @@
+pub use crate::constants::*;
+pub use crate::error::Error;
+pub use crate::utils::*;
diff --git a/src/state.rs b/src/state.rs
index fbed73b..4733dfb 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -1,10 +1,5 @@
-use crate::{
-    constants::{CHAIN_ID, GRPC_URL},
-    error::Error,
-    tokens::ContractInfo,
-};
-use ::keplr::Keplr;
-use ::keplr::KeyInfo;
+use crate::keplr::{Keplr, KeyInfo};
+use crate::{constants::*, error::Error, tokens::ContractInfo};
 use codee::string::JsonSerdeCodec;
 use leptos::prelude::*;
 use send_wrapper::SendWrapper;
@@ -44,7 +39,7 @@ impl TokenMap {
         let token_map: HashMap<String, ContractInfo> =
             serde_json::from_slice(json).expect("Failed to deserialize token_map");
 
-        Self { 0: token_map }
+        Self(token_map)
     }
 }
 
diff --git a/src/utils/mod.rs b/src/utils.rs
similarity index 76%
rename from src/utils/mod.rs
rename to src/utils.rs
index 636b8ae..6270b18 100644
--- a/src/utils/mod.rs
+++ b/src/utils.rs
@@ -1,4 +1,4 @@
-use web_sys::window::*;
+use leptos::prelude::window;
 
 pub fn alert(msg: impl AsRef<str>) {
     let _ = window().alert_with_message(msg.as_ref());