diff --git a/examples/test.rs b/examples/test.rs
index ff4f7c6..0afaec1 100644
--- a/examples/test.rs
+++ b/examples/test.rs
@@ -5,7 +5,8 @@
 //
 
 use rustwallet::{
-    free_cwallet, generate_sec_key, get_address, new_wallet, sign, sign_for_tran, CWallet,
+    free_cwallet, generate_sec_key, get_address, get_public_key, new_wallet, rdecrypt, rencrypt,
+    sign, sign_for_tran, str_deflate, str_inflate, CWallet,
 };
 use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
@@ -64,13 +65,13 @@ fn main() {
             str_to_cchar!(key2),
         );
         print_cchar!(address2);
-        let key__public = generate_sec_key(
+        let key_public = get_public_key(
             str_to_cchar!(msg_key),
             str_to_cchar!(key0),
             str_to_cchar!(key1),
             str_to_cchar!(key2),
         );
-        print_cchar!(key_private);
+        print_cchar!(key_public);
         let key_private = generate_sec_key(
             str_to_cchar!(msg_key),
             str_to_cchar!(key0),
@@ -78,32 +79,48 @@ fn main() {
             str_to_cchar!(key2),
         );
         print_cchar!(key_private);
-        // let tmp_cwallet2 = restore_wallet(&tmp_cwallet);
-        // let address3 = get_address(&tmp_cwallet2);
-        // print_cchar!(address3);
+        let msg = "hello world";
+        let str_signed = sign(
+            str_to_cchar!(msg_key),
+            str_to_cchar!(key0),
+            str_to_cchar!(key1),
+            str_to_cchar!(key2),
+            str_to_cchar!(msg),
+        );
+        print_cchar!(str_signed);
+        let tran_str = "0cd00eb0126aeed39762579ce94c90a04695ad17fbd5e79aa4e9fc4a34ba32a5";
+        let str_signed2 = sign_for_tran(
+            str_to_cchar!(msg_key),
+            str_to_cchar!(key0),
+            str_to_cchar!(key1),
+            str_to_cchar!(key2),
+            str_to_cchar!(tran_str),
+        );
+        print_cchar!(str_signed2);
 
-        // let sign_str = sign(&tmp_cwallet2,str_to_cchar!("111"));
-        // print_cchar!(sign_str);
+        let str_encrypt = rencrypt(
+            str_to_cchar!(msg_key),
+            str_to_cchar!(key0),
+            str_to_cchar!(key1),
+            str_to_cchar!(key2),
+            str_to_cchar!(msg),
+        );
+        print_cchar!(str_encrypt);
 
-        // let cwallet3 = reset_wallet(&tmp_cwallet2);
-        // print_wallet(&cwallet3);
-        // let sign_str2 = sign(&cwallet3, str_to_cchar!("111"));
-        // print_cchar!(sign_str2);
-        // print_wallet(&tmp_cwallet2);
-        // println!("---- saving the wallet to wallet.json ----");
-        // save_wallet(&wallet);
-        // println!("---- saved! ----");
+        let str_decrypt = rdecrypt(
+            str_to_cchar!(msg_key),
+            str_to_cchar!(key0),
+            str_to_cchar!(key1),
+            str_to_cchar!(key2),
+            str_encrypt,
+        );
+        print_cchar!(str_decrypt);
 
-        // println!("---- fetching the saved wallet to be exposed to C-side ----");
-        // let fetched = fetch_cwallet();
-        // print_wallet(&fetched);
-        // sign();
-        // let sign_str = "111";
-        // let cstr = std::ffi::CString::new(sign_str).unwrap();
-        // sss_sign(cstr.into_raw());
+        let str_encode = str_deflate(key_public);
+        print_cchar!(str_encode);
 
-        // // free_cwallet(wallet); // 对应 generate_cwallet()
-        // free_cwallet(fetched); // 对应 fetch_wallet()
+        let str_decode = str_inflate(str_encode);
+        print_cchar!(str_decode);
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index e75a952..fcf245e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,64 +17,52 @@ use utils::str_utils::{base64_to_hex, hex_to_base64};
 
 // #[cfg(target_os = "android")]
 // mod android;
-macro_rules! cchar_to_str{
-    ($p1:expr) => {
-        {
-            let s = CStr::from_ptr($p1);
-            let ps = s.to_str().unwrap();
-            ps
-        }
-    }
+macro_rules! cchar_to_str {
+    ($p1:expr) => {{
+        let s = CStr::from_ptr($p1);
+        let ps = s.to_str().unwrap();
+        ps
+    }};
 }
 
-macro_rules! cchar_to_string{
-    ($p1:expr) => {
-        {
-            let s = CStr::from_ptr($p1);
-            let ps = s.to_str().unwrap();
-            ps.to_string()
-        }
-    }
+macro_rules! cchar_to_string {
+    ($p1:expr) => {{
+        let s = CStr::from_ptr($p1);
+        let ps = s.to_str().unwrap();
+        ps.to_string()
+    }};
 }
 
-macro_rules! cchar_to_ostring{
-    ($p1:expr) => {
-        {
-            let s = CStr::from_ptr($p1);
-            let pb = s.to_str().unwrap();
-            let result = if pb.is_empty() {
-                None
-            } else {
-                Some(pb.to_string())
-            };
-            result
-        }
-    }
+macro_rules! cchar_to_ostring {
+    ($p1:expr) => {{
+        let s = CStr::from_ptr($p1);
+        let pb = s.to_str().unwrap();
+        let result = if pb.is_empty() {
+            None
+        } else {
+            Some(pb.to_string())
+        };
+        result
+    }};
 }
 
 macro_rules! str_to_cchar {
-    ($p1:expr) => {
-        {
-            let msgkey = CString::new($p1).unwrap();
-            let c_msgkey: *mut c_char = msgkey.into_raw();
-            c_msgkey
-        }
-    };
+    ($p1:expr) => {{
+        let msgkey = CString::new($p1).unwrap();
+        let c_msgkey: *mut c_char = msgkey.into_raw();
+        c_msgkey
+    }};
 }
 
-macro_rules! ostr_to_cchar{
-    ($p1:expr) => {
-        {
-            let key = match $p1 {
-                Some(val) => {
-                    CString::new(val).unwrap()
-                },
-                None => CString::new("").unwrap()
-            };
-            let c_key: *mut c_char = key.into_raw();
-            c_key
-        }
-    }
+macro_rules! ostr_to_cchar {
+    ($p1:expr) => {{
+        let key = match $p1 {
+            Some(val) => CString::new(val).unwrap(),
+            None => CString::new("").unwrap(),
+        };
+        let c_key: *mut c_char = key.into_raw();
+        c_key
+    }};
 }
 
 #[repr(C)]
@@ -92,7 +80,6 @@ pub unsafe extern "C" fn new_wallet(msg: *const c_char) -> CWallet {
     convert_to_cwallet(rust_wallet)
 }
 
-
 #[no_mangle]
 pub unsafe extern "C" fn reset_wallet(
     msg_key: *const c_char,
@@ -119,7 +106,7 @@ pub unsafe extern "C" fn get_address(
     master_key: *const c_char,
     second_key: *const c_char,
     backup_key: *const c_char,
-) -> *mut c_char{
+) -> *mut c_char {
     let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
     let address = rwallet.get_address();
     let address_str = format!("{:?}", address);
@@ -127,6 +114,19 @@ pub unsafe extern "C" fn get_address(
     c_address.into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn get_public_key(
+    msg_key: *const c_char,
+    master_key: *const c_char,
+    second_key: *const c_char,
+    backup_key: *const c_char,
+) -> *mut c_char {
+    let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
+    let pk = rwallet.get_public_key();
+    let c_pk = CString::new(pk.to_string()).unwrap();
+    c_pk.into_raw()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn generate_sec_key(
     msg_key: *const c_char,
@@ -146,8 +146,8 @@ pub unsafe extern "C" fn sign(
     master_key: *const c_char,
     second_key: *const c_char,
     backup_key: *const c_char,
-    msg: *const c_char
-) -> *mut c_char{
+    msg: *const c_char,
+) -> *mut c_char {
     let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
     let msg_str = cchar_to_str!(msg);
     let signature = rwallet.sign(msg_str);
@@ -163,11 +163,12 @@ pub unsafe extern "C" fn sign_for_tran(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
-    backup_key: *const c_char, 
-    msg: *const c_char
-) -> *mut c_char{
+    backup_key: *const c_char,
+    msg: *const c_char,
+) -> *mut c_char {
     let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
     let msg_str = cchar_to_str!(msg);
+    println!("msg for sign tran: {}", &msg_str);
     let signature = rwallet.sign_for_tran(msg_str);
     let (r, recid) = match signature {
         Ok((v, _recid)) => (v, _recid),
@@ -182,12 +183,12 @@ pub unsafe extern "C" fn rencrypt(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
-    backup_key: *const c_char, 
-    msg: *const c_char
-) -> *mut c_char{
+    backup_key: *const c_char,
+    msg: *const c_char,
+) -> *mut c_char {
     let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
     let msg_str = cchar_to_str!(msg);
-    let msg_encrypt = match rwallet.zencrypt(msg_str){
+    let msg_encrypt = match rwallet.zencrypt(msg_str) {
         Ok(v) => v,
         Err(err) => panic!("error encrypt: {:?}", err),
     };
@@ -199,12 +200,12 @@ pub unsafe extern "C" fn rdecrypt(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
-    backup_key: *const c_char, 
-    msg: *const c_char
-) -> *mut c_char{
+    backup_key: *const c_char,
+    msg: *const c_char,
+) -> *mut c_char {
     let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
     let msg_str = cchar_to_str!(msg);
-    let msg_decrypt = match rwallet.zdecrypt(msg_str){
+    let msg_decrypt = match rwallet.zdecrypt(msg_str) {
         Ok(v) => v,
         Err(err) => panic!("error decrypt: {:?}", err),
     };
@@ -245,7 +246,7 @@ unsafe fn generate_rwallet(
     master_key: *const c_char,
     second_key: *const c_char,
     backup_key: *const c_char,
-) ->Wallet {
+) -> Wallet {
     let pmsg = cchar_to_string!(msg_key);
     let pm = cchar_to_string!(master_key);
     let second_key = cchar_to_ostring!(second_key);
@@ -254,6 +255,6 @@ unsafe fn generate_rwallet(
         msg_key: pmsg,
         master_key: pm,
         second_key: second_key,
-        backup_key: backup_key
+        backup_key: backup_key,
     }
 }
diff --git a/src/wallet/wallet_impl.rs b/src/wallet/wallet_impl.rs
index e58c12c..802f960 100644
--- a/src/wallet/wallet_impl.rs
+++ b/src/wallet/wallet_impl.rs
@@ -178,7 +178,10 @@ impl Wallet {
     {
         let secp = Secp256k1::new();
         let secret_key = self.get_secret_key();
-        let hex_str = hex::decode(msg).unwrap();
+        let hex_str = match hex::decode(msg){
+            Ok(v) => v,
+            Err(e) => panic!("error decode hex str: {}", e),
+        };
         let message_to_hash = Message::from_slice(&hex_str).unwrap();
         let (_recovery_id, signature) = secp
             .sign_ecdsa_recoverable(&message_to_hash, &secret_key)
@@ -192,29 +195,33 @@ impl Wallet {
         let pk = self.get_public_key();
         let pk = &pk.serialize();
         let msg = msg.as_bytes();
-        println!("msg before encrypt: {:?}", msg);
+        // println!("msg before encrypt: {:?}", msg);
         let msg_encrypt = match encrypt(pk, &msg) {
             Ok(v) => v,
             Err(e) => panic!("error encrypt content: {}", e),
         };
-        println!("msg after encrypt: {:?}", &msg_encrypt);
+        // println!("msg after encrypt: {:?}", &msg_encrypt);
         let str_encrypt = hex::encode(&msg_encrypt);
         Ok(str_encrypt)
     }
 
-    pub fn zdecrypt(&self, msg: &str) -> Result<String> {
+    pub fn zdecrypt(&self, msg1: &str) -> Result<String> {
         let sk = self.get_secret_key();
         let sk = sk.secret_bytes();
+        let mut msg: String = msg1.clone().to_string();
+        if msg.len() % 2 == 1 {
+            msg = "0".to_owned() + &msg;
+        } 
+        println!("msg to decrypt: {:?}", &msg);
         let msg = match hex::decode(&msg) {
             Ok(v) => v,
-            Err(e) => panic!("error decode hex str {}", e),
+            Err(e) => panic!("error decode hex str: {}", e),
         };
-        println!("msg to decrypt: {:?}", &msg);
         let msg_decrypt = match decrypt(&sk, &msg) {
             Ok(v) => v,
             Err(e) => panic!("error decrypt content: {}", e),
         };
-        println!("msg after decrypt: {:?}", &msg_decrypt);
+        // println!("msg after decrypt: {:?}", &msg_decrypt);
         // let msg_decrypt = hex::encode(msg_decrypt);
         let str_decrypt = match str::from_utf8(&msg_decrypt) {
             Ok(v) => v,
@@ -225,4 +232,3 @@ impl Wallet {
         Ok(result)
     }
 }
-