diff --git a/README.md b/README.md
index 8747b2b..5e74149 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@ The SDK supports RESTful API invoking, and concurrently subscribing the market,
   - [Client](#Client)
   - [Response](#Response)
   - [Init function](#Init-function)
+  - [Logging](#logging)
 - [Request examples](#Request-examples)
   - [Common data](#Common-data)
   - [Market data](#Market-data)
@@ -46,9 +47,9 @@ client := new(client.CommonClient).Init(config.Host)
 resp, err := client.GetTimestamp()
 
 if err != nil {
-  fmt.Println(err)
+  applogger.Error("Get timestamp error: %s", err)
 } else {
-  fmt.Println("timestamp:", resp)
+  applogger.Info("Get timestamp: %d", resp)
 }
 
 
@@ -56,11 +57,12 @@ if err != nil {
 client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 resp, err := client.GetAccountInfo()
 if err != nil {
-  fmt.Println(err)
+  applogger.Error("Get account error: %s", err)
 } else {
+  applogger.Info("Get account, count=%d", len(resp))
   for _, result := range resp {
-    fmt.Printf("account: %+v\n", result)
-    }
+    applogger.Info("account: %+v", result)
+  }
 }
 ```
 
@@ -183,9 +185,9 @@ resp, err := client.GetTimestamp()
 
 // Check error first
 if err != nil {
-  fmt.Println(err)
+  applogger.Error("Get timestamp error: %s", err)
 } else {
-  fmt.Println("timestamp:", resp)
+  applogger.Info("Get timestamp: %d", resp)
 }
 ```
 
@@ -194,7 +196,7 @@ For array struct, you can use for/range to iterate each element
 ```go
 // Check the status of response and print some properties
 for _, kline := range resp {
-  fmt.Println("High: ", kline.High, "Low:", kline.Low)
+  applogger.Info("High=%f, Low=%f", kline.High, kline.Low)
 }
 ```
 
@@ -202,7 +204,7 @@ for _, kline := range resp {
 
 Golang is not a pure object oriented programming language, and there is no native constructor. In this SDK, every struct has an ***Init*** function for each struct, you must call Init function first, otherwise the member variables may not be initialized expected.
 
-###Logging
+### Logging
 
 This SDK uses the high performance logging library [zap](https://github.com/uber-go/zap), which provide different kind of loggers. To better support format message, this SDK uses the SugaredLogger, and wrapped a few interfaces in package *logging/applogger*. It has below features:
 
@@ -210,7 +212,7 @@ This SDK uses the high performance logging library [zap](https://github.com/uber
 2. Support multiple levels (Fatal, Error, Panic, Warn, Info and Debug) and minimum log level
 3. Support colorful text (by default)
 
-You can customize your own logging by updating *applogger.go* file.
+You can customize your own logging by updating *applogger.go* file.
 
 ## Request Examples
 
@@ -423,19 +425,9 @@ client := new(marketwebsocketclient.Last24hCandlestickWebSocketClient).Init(conf
 client.SetHandler(
   // Connected handler
   func() {
-    err := client.Request("btcusdt", "1608")
-      if err != nil {
-        fmt.Printf("Sent error: %s\n", err)
-      } else {
-        fmt.Println("Sent request")
-      }
+    client.Request("btcusdt", "1608")
 
-    err = client.Subscribe("btcusdt", "1608")
-      if err != nil {
-        fmt.Printf("Subscribe error: %s\n", err)
-      } else {
-        fmt.Println("Sent subscription")
-      }
+    client.Subscribe("btcusdt", "1608")
   },
   // Response handler
   func(resp interface{}) {
@@ -444,27 +436,23 @@ client.SetHandler(
         if &candlestickResponse != nil {
           if candlestickResponse.Tick != nil {
             t := candlestickResponse.Tick
-              fmt.Printf("Candlestick update, id: %d, count: %v, volume: %v [%v-%v-%v-%v]\n",
+              applogger.Info("Candlestick update, id: %d, count: %v, volume: %v [%v-%v-%v-%v]",
                          t.Id, t.Count, t.Vol, t.Open, t.Close, t.Low, t.High)
           }
 
           if candlestickResponse.Data != nil {
             t := candlestickResponse.Data
-              fmt.Printf("Candlestick data, id: %d, count: %v, volume: %v [%v-%v-%v-%v]\n",
+              applogger.Info("Candlestick data, id: %d, count: %v, volume: %v [%v-%v-%v-%v]",
                          t.Id, t.Count, t.Vol, t.Open, t.Close, t.Low, t.High)
           }
         }
       } else {
-        fmt.Printf("Unknown response: %v\n", resp)
+        applogger.Warn("Unknown response: %v", resp)
       }
   })
 
 // Connect to the server and wait for the handler to handle the response
-err := client.Connect(true)
-if err != nil {
-  fmt.Printf("Client connect error: %s\n", err)
-  return
-}
+client.Connect(true)
 ```
 
 ### Subscribe account update
@@ -480,14 +468,9 @@ if err != nil {
     // Authentication response handler
     func(resp *auth.WebSocketV2AuthenticationResponse) {
       if resp.IsSuccess() {
-        err := client.Subscribe("1", "1149")
-        if err != nil {
-          fmt.Printf("Subscribe error: %s\n", err)
-        } else {
-          fmt.Println("Sent subscription")
-        }
+        client.Subscribe("1", "1149")        
       } else {
-        fmt.Printf("Authentication error, code: %d, message:%s\n", resp.Code, resp.Message)
+        applogger.Error("Authentication error, code: %d, message:%s", resp.Code, resp.Message)
       }
     },
     // Response handler
@@ -496,31 +479,27 @@ if err != nil {
       if ok {
         if subResponse.Action == "sub" {
           if subResponse.IsSuccess() {
-            fmt.Printf("Subscription topic %s successfully\n", subResponse.Ch)
+            applogger.Info("Subscription topic %s successfully", subResponse.Ch)
           } else {
-            fmt.Printf("Subscription topic %s error, code: %d, message: %s\n", subResponse.Ch, subResponse.Code, subResponse.Message)
+            applogger.Error("Subscription topic %s error, code: %d, message: %s", subResponse.Ch, subResponse.Code, subResponse.Message)
           }
         } else if subResponse.Action == "push" {
           if subResponse.Data != nil {
             b := subResponse.Data
             if b.ChangeTime == 0 {
-              fmt.Printf("Account overview, id: %d, currency: %s, balance: %s\n", b.AccountId, b.Currency, b.Balance)
+              applogger.Info("Account overview, id: %d, currency: %s, balance: %s", b.AccountId, b.Currency, b.Balance)
             } else {
-              fmt.Printf("Account update, id: %d, currency: %s, balance: %s, time: %d\n", b.AccountId, b.Currency, b.Balance, b.ChangeTime)
+              applogger.Info("Account update, id: %d, currency: %s, balance: %s, time: %d", b.AccountId, b.Currency, b.Balance, b.ChangeTime)
             }
           }
         }
       } else {
-        fmt.Printf("Received unknown response: %v\n", resp)
+        applogger.Warn("Received unknown response: %v", resp)
       }
     })
 
   // Connect to the server and wait for the handler to handle the response
-  err := client.Connect(true)
-  if err != nil {
-    fmt.Printf("Client Connect error: %s\n", err)
-    return
-  }
+  client.Connect(true)
 ```
 
 ### Subscribe order update
@@ -537,14 +516,9 @@ if err != nil {
     func(resp *auth.WebSocketV2AuthenticationResponse) {
       if resp.IsSuccess() {
         // Subscribe if authentication passed
-        err := client.Subscribe("btcusdt", "1149")
-        if err != nil {
-          fmt.Printf("Subscribe error: %s\n", err)
-        } else {
-          fmt.Println("Sent subscription")
-        }
+        client.Subscribe("btcusdt", "1149")
       } else {
-        fmt.Printf("Authentication error, code: %d, message:%s\n", resp.Code, resp.Message)
+        applogger.Info("Authentication error, code: %d, message:%s", resp.Code, resp.Message)
       }
     },
     // Response handler
@@ -553,28 +527,24 @@ if err != nil {
       if ok {
         if subResponse.Action == "sub" {
           if subResponse.IsSuccess() {
-            fmt.Printf("Subscription topic %s successfully\n", subResponse.Ch)
+            applogger.Info("Subscription topic %s successfully", subResponse.Ch)
           } else {
-            fmt.Printf("Subscription topic %s error, code: %d, message: %s\n", subResponse.Ch, subResponse.Code, subResponse.Message)
+            applogger.Error("Subscription topic %s error, code: %d, message: %s", subResponse.Ch, subResponse.Code, subResponse.Message)
           }
         } else if subResponse.Action == "push" {
           if subResponse.Data != nil {
             o := subResponse.Data
-            fmt.Printf("Order update, event: %s, symbol: %s, type: %s, status: %s\n",
+            applogger.Info("Order update, event: %s, symbol: %s, type: %s, status: %s",
               o.EventType, o.Symbol, o.Type, o.OrderStatus)
           }
         }
       } else {
-        fmt.Printf("Received unknown response: %v\n", resp)
+        applogger.Warn("Received unknown response: %v", resp)
       }
     })
 
   // Connect to the server and wait for the handler to handle the response
-  err := client.Connect(true)
-  if err != nil {
-    fmt.Printf("Client Connect error: %s\n", err)
-    return
-  }
+  client.Connect(true)
 ```
 
 ### Subscribe trade update
@@ -591,14 +561,9 @@ if err != nil {
     func(resp *auth.WebSocketV2AuthenticationResponse) {
       if resp.IsSuccess() {
         // Subscribe if authentication passed
-        err := client.Subscribe("btcusdt", "1149")
-        if err != nil {
-          fmt.Printf("Subscribe error: %s\n", err)
-        } else {
-          fmt.Println("Sent subscription")
-        }
+        client.Subscribe("btcusdt", "1149")
       } else {
-        fmt.Printf("Authentication error, code: %d, message:%s\n", resp.Code, resp.Message)
+        applogger.Error("Authentication error, code: %d, message:%s", resp.Code, resp.Message)
       }
     },
     // Response handler
@@ -607,28 +572,24 @@ if err != nil {
       if ok {
         if subResponse.Action == "sub" {
           if subResponse.IsSuccess() {
-            fmt.Printf("Subscription topic %s successfully\n", subResponse.Ch)
+            applogger.Info("Subscription topic %s successfully", subResponse.Ch)
           } else {
-            fmt.Printf("Subscription topic %s error, code: %d, message: %s\n", subResponse.Ch, subResponse.Code, subResponse.Message)
+            applogger.Error("Subscription topic %s error, code: %d, message: %s", subResponse.Ch, subResponse.Code, subResponse.Message)
           }
         } else if subResponse.Action == "push" {
           if subResponse.Data != nil {
             o := subResponse.Data
-            fmt.Printf("Order update, symbol: %s, order id: %d, price: %s, volume: %s\n",
+            applogger.Info("Order update, symbol: %s, order id: %d, price: %s, volume: %s",
               o.Symbol, o.OrderId, o.TradePrice, o.TradeVolume)
           }
         }
       } else {
-        fmt.Printf("Received unknown response: %v\n", resp)
+        applogger.Warn("Received unknown response: %v", resp)
       }
     })
 
   // Connect to the server and wait for the handler to handle the response
-  err := client.Connect(true)
-  if err != nil {
-    fmt.Printf("Client Connect error: %s\n", err)
-    return
-  }
+  client.Connect(true)
 ```
 
 ## Unsubscribe
diff --git a/cmd/accountclientexample/accountclientexample.go b/cmd/accountclientexample/accountclientexample.go
index e257a96..e64c16e 100644
--- a/cmd/accountclientexample/accountclientexample.go
+++ b/cmd/accountclientexample/accountclientexample.go
@@ -1,8 +1,8 @@
 package accountclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
@@ -14,48 +14,55 @@ func RunAllExamples() {
 	getAccountBalance()
 	getAccountHistory()
 	getAccountLedger()
-	getSubUserAccount()
-	subUserManagement()
-	futuresTransfer()
-	getSubUserAggregateBalance()
+	transferFromFutureToSpot()
+	transferFromSpotToFuture()
 	subUserTransfer()
+	getSubUserAggregateBalance()
+	getSubUserAccount()
+	lockSubUser()
+	unlockSubUser()
 }
 
-//  Get a list of accounts owned by this API user.
 func getAccountInfo() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetAccountInfo()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get account error: %s", err)
 	} else {
+		applogger.Info("Get account, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("account: %+v\n", result)
+			applogger.Info("account: %+v", result)
 		}
 
 	}
 }
 
-//   Get the balance of an account specified by account id.
 func getAccountBalance() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetAccountBalance(config.AccountId)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get account balance error: %s", err)
 	} else {
-		fmt.Println("Id: ", resp.Id, "Type: ", resp.Type, "State: ", resp.State)
+		applogger.Info("Get account balance: id=%d, type=%s, state=%s, count=%d",
+			resp.Id, resp.Type, resp.State, len(resp.List))
+		if resp.List != nil {
+			for _, result := range resp.List {
+				applogger.Info("Account balance: %+v", result)
+			}
+		}
 	}
 }
 
-//  Get the amount changes of specified user's account.
 func getAccountHistory() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	getAccountHistoryOptionalRequest := getrequest.GetAccountHistoryOptionalRequest{}
 	resp, err := client.GetAccountHistory(config.AccountId, getAccountHistoryOptionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get account history error: %s", err)
 	} else {
+		applogger.Info("Get account history, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Println(result)
+			applogger.Info("Account history: %+v", result)
 		}
 	}
 }
@@ -65,66 +72,68 @@ func getAccountLedger() {
 	getAccountLedgerOptionalRequest := getrequest.GetAccountLedgerOptionalRequest{}
 	resp, err := client.GetAccountLedger(config.AccountId, getAccountLedgerOptionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get account ledger error: %s", err)
 	} else {
+		applogger.Info("Get account ledger, count=%d", len(resp))
 		for _, l := range resp {
-			fmt.Printf("Account legder: AccountId: %d, Currency: %s, Amount: %v, Transferer: %d, Transferee: %d\n", l.AccountId, l.Currency, l.TransactAmt, l.Transferer, l.Transferee)
+			applogger.Info("Account legder: AccountId: %d, Currency: %s, Amount: %v, Transferer: %d, Transferee: %d", l.AccountId, l.Currency, l.TransactAmt, l.Transferer, l.Transferee)
 		}
 	}
 }
 
-//  Get the balance of a sub-account specified by sub-uid.
 func getSubUserAccount() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetSubUserAccount(config.SubUid)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get sub user account error: %s", err)
 	} else {
-		for _, result := range resp {
-			fmt.Println("Id: ", result.Id, "Type: ", result.Type)
+		applogger.Info("Get sub user account, count=%d", len(resp))
+		for _, account := range resp {
+			applogger.Info("account id: %d, type: %s, currency count=%d", account.Id, account.Type, len(account.List))
+			if account.List != nil {
+				for _, currency := range account.List {
+					applogger.Info("currency: %+v", currency)
+				}
+			}
 		}
-
 	}
 }
 
-//  This func allows parent user to lock or unlock a specific sub user.
-func subUserManagement() {
+func transferFromFutureToSpot() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
-	subUserManagementRequest := postrequest.SubUserManagementRequest{SubUid: config.SubUid, Action: "unlock"}
-	resp, err := client.SubUserManagement(subUserManagementRequest)
+	futuresTransferRequest := postrequest.FuturesTransferRequest{Currency: "btc", Amount: decimal.NewFromFloat(0.001), Type: "futures-to-pro"}
+	resp, err := client.FuturesTransfer(futuresTransferRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Transfer from future to spot error: %s", err)
 	} else {
-		fmt.Printf("resp: %+v\n", resp)
+		applogger.Info("Transfer from future to spot success: id=%d", resp)
 	}
 }
 
-//  Transfer fund between spot account and future contract account.
-func futuresTransfer() {
+func transferFromSpotToFuture() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
-	futuresTransferRequest := postrequest.FuturesTransferRequest{Currency: "btc", Amount: decimal.NewFromFloat(0.001), Type: "futures-to-pro"}
+	futuresTransferRequest := postrequest.FuturesTransferRequest{Currency: "btc", Amount: decimal.NewFromFloat(0.001), Type: "pro-to-futures"}
 	resp, err := client.FuturesTransfer(futuresTransferRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Transfer from spot to future error: %s", err)
 	} else {
-		fmt.Println(resp)
+		applogger.Info("Transfer from spot to future success: id=%d", resp)
 	}
 }
 
-// Get the balances of all the sub-account aggregated.
 func getSubUserAggregateBalance() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetSubUserAggregateBalance()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get sub user aggregated balance error: %s", err)
 	} else {
+		applogger.Info("Get sub user aggregated balance, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("result: %+v\n", result)
+			applogger.Info("balance: %+v", result)
 		}
 	}
 }
 
-// Transfer asset between parent and sub account.
 func subUserTransfer() {
 	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	currency := "usdt"
@@ -136,9 +145,31 @@ func subUserTransfer() {
 	}
 	resp, err := client.SubUserTransfer(subUserTransferRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Transfer error: %s", err)
 	} else {
-		fmt.Println(resp)
+		applogger.Info("Transfer successfully, id=%s", resp)
 
 	}
 }
+
+func lockSubUser() {
+	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
+	subUserManagementRequest := postrequest.SubUserManagementRequest{SubUid: config.SubUid, Action: "lock"}
+	resp, err := client.SubUserManagement(subUserManagementRequest)
+	if err != nil {
+		applogger.Error("Lock sub user error: %s", err)
+	} else {
+		applogger.Info("Lock sub user: %+v", resp)
+	}
+}
+
+func unlockSubUser() {
+	client := new(client.AccountClient).Init(config.AccessKey, config.SecretKey, config.Host)
+	subUserManagementRequest := postrequest.SubUserManagementRequest{SubUid: config.SubUid, Action: "unlock"}
+	resp, err := client.SubUserManagement(subUserManagementRequest)
+	if err != nil {
+		applogger.Error("Unlock sub user error: %s", err)
+	} else {
+		applogger.Info("Unlock sub user: %+v", resp)
+	}
+}
diff --git a/cmd/accountwebsocketclientexample/accountwebsocketclientexample.go b/cmd/accountwebsocketclientexample/accountwebsocketclientexample.go
index ade1f63..ef311db 100644
--- a/cmd/accountwebsocketclientexample/accountwebsocketclientexample.go
+++ b/cmd/accountwebsocketclientexample/accountwebsocketclientexample.go
@@ -26,12 +26,12 @@ func reqAccountUpdateV1() {
 			if resp.ErrorCode == 0 {
 				err := client.Request("")
 				if err != nil {
-					fmt.Printf("Request error: %s\n", err)
+					applogger.Error("Request error: %s", err)
 				} else {
-					fmt.Println("Sent request")
+					applogger.Debug("Sent request")
 				}
 			} else {
-				fmt.Printf("Authentication error: %d\n", resp.ErrorCode)
+				applogger.Error("Authentication error: %d", resp.ErrorCode)
 			}
 
 		},
@@ -41,23 +41,23 @@ func reqAccountUpdateV1() {
 			if ok {
 				if &reqResponse.Data != nil {
 					for _, a := range reqResponse.Data {
-						fmt.Printf("Account id: %d, type: %s, state: %s\n", a.Id, a.Type, a.State)
+						applogger.Info("Account id: %d, type: %s, state: %s", a.Id, a.Type, a.State)
 						if &a.List != nil {
 							for _, b := range a.List {
-								fmt.Printf("Currency: %s, type: %s, balance: %s\n", b.Currency, b.Type, b.Balance)
+								applogger.Info("Currency: %s, type: %s, balance: %s", b.Currency, b.Type, b.Balance)
 							}
 						}
 					}
 				}
 			} else {
-				fmt.Printf("Received unknown response: %v\n", resp)
+				applogger.Warn("Received unknown response: %+v", resp)
 			}
 		})
 
 	// Connect to the server and wait for the handler to handle the response
 	err := client.Connect(false)
 	if err != nil {
-		fmt.Printf("Client Connect error: %s\n", err)
+		applogger.Error("Client Connect error: %s", err)
 		return
 	}
 
@@ -67,7 +67,7 @@ func reqAccountUpdateV1() {
 
 	// Close the connection
 	client.Close()
-	fmt.Println("Client closed")
+	applogger.Info("Client closed")
 }
 
 func subAccountUpdateV1() {
@@ -81,12 +81,12 @@ func subAccountUpdateV1() {
 			if resp.ErrorCode == 0 {
 				err := client.Subscribe("1", "1250")
 				if err != nil {
-					fmt.Printf("Subscribe error: %s\n", err)
+					applogger.Error("Subscribe error: %s", err)
 				} else {
-					fmt.Println("Sent subscription")
+					applogger.Debug("Sent subscription")
 				}
 			} else {
-				fmt.Printf("Authentication error: %d\n", resp.ErrorCode)
+				applogger.Error("Authentication error: %d", resp.ErrorCode)
 			}
 
 		},
@@ -95,22 +95,22 @@ func subAccountUpdateV1() {
 			subResponse, ok := resp.(account.SubscribeAccountV1Response)
 			if ok {
 				if &subResponse.Data != nil {
-					fmt.Printf("Account update event: %s\n", subResponse.Data.Event)
+					applogger.Info("Account update event: %s", subResponse.Data.Event)
 					if &subResponse.Data.List != nil {
 						for _, b := range subResponse.Data.List {
-							fmt.Printf("Account id: %d, currency: %s, type: %s, balance: %s\n", b.AccountId, b.Currency, b.Type, b.Balance)
+							applogger.Info("Account id: %d, currency: %s, type: %s, balance: %s", b.AccountId, b.Currency, b.Type, b.Balance)
 						}
 					}
 				}
 			} else {
-				fmt.Printf("Received unknown response: %v\n", resp)
+				applogger.Warn("Received unknown response: %+v", resp)
 			}
 		})
 
 	// Connect to the server and wait for the handler to handle the response
 	err := client.Connect(true)
 	if err != nil {
-		fmt.Printf("Client Connect error: %s\n", err)
+		applogger.Error("Client Connect error: %s", err)
 		return
 	}
 
@@ -120,12 +120,12 @@ func subAccountUpdateV1() {
 	// Unsubscribe the topic
 	err = client.UnSubscribe("1", "1250")
 	if err != nil {
-		fmt.Printf("UnSubscribe error: %s\n", err)
+		applogger.Error("UnSubscribe error: %s", err)
 	}
 
 	// Close the connection
 	client.Close()
-	fmt.Println("Client closed")
+	applogger.Info("Client closed")
 }
 
 func subAccountUpdateV2() {
@@ -163,7 +163,7 @@ func subAccountUpdateV2() {
 					}
 				}
 			} else {
-				applogger.Error("Received unknown response: %v", resp)
+				applogger.Warn("Received unknown response: %v", resp)
 			}
 		})
 
diff --git a/cmd/commonclientexample/commonclientexample.go b/cmd/commonclientexample/commonclientexample.go
index c21c758..1ec1fcb 100644
--- a/cmd/commonclientexample/commonclientexample.go
+++ b/cmd/commonclientexample/commonclientexample.go
@@ -1,8 +1,8 @@
 package commonclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 )
@@ -19,9 +19,9 @@ func getSystemStatus() {
 	client := new(client.CommonClient).Init(config.Host)
 	resp, err := client.GetSystemStatus()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get system status error: %s", err)
 	} else {
-		fmt.Printf("Get system status %s\n", resp)
+		applogger.Info("Get system status %s", resp)
 	}
 }
 
@@ -29,12 +29,12 @@ func getSymbols() {
 	client := new(client.CommonClient).Init(config.Host)
 	resp, err := client.GetSymbols()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get symbols error: %s", err)
 	} else {
+		applogger.Info("Get symbols, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("symbol:%s, BaseCurrency:%s, QuoteCurrency:%s \n", result.Symbol, result.BaseCurrency, result.QuoteCurrency)
+			applogger.Info("symbol=%s, BaseCurrency=%s, QuoteCurrency=%s", result.Symbol, result.BaseCurrency, result.QuoteCurrency)
 		}
-		fmt.Printf("There are total %d symbols\n", len(resp))
 	}
 }
 
@@ -43,12 +43,12 @@ func getCurrencys() {
 	resp, err := client.GetCurrencys()
 
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get currency error: %s", err)
 	} else {
+		applogger.Info("Get currency, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Println(result)
+			applogger.Info("currency: %+v", result)
 		}
-		fmt.Printf("There are total %d currencies\n", len(resp))
 	}
 }
 
@@ -59,20 +59,16 @@ func getV2ReferenceCurrencies() {
 	resp, err := client.GetV2ReferenceCurrencies(optionalRequest)
 
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get reference currency error: %s", err)
 	} else {
+		applogger.Info("Get reference currency, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("currency:%s, ", result.Currency)
+			applogger.Info("currency:%s, ", result.Currency)
 
 			for _, chain := range result.Chains {
-				fmt.Printf("Chain:%s, ", chain.Chain)
-				fmt.Printf("BaseChain:%s, ", chain.BaseChain)
-				fmt.Printf("WithdrawPrecision:%d ", chain.WithdrawPrecision)
+				applogger.Info("Chain: %+v", chain)
 			}
-			fmt.Printf("\n")
 		}
-
-		fmt.Printf("There are total %d CurrencyChain\n", len(resp))
 	}
 }
 
@@ -81,8 +77,8 @@ func getTimestamp() {
 	resp, err := client.GetTimestamp()
 
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get timestamp error: %s", err)
 	} else {
-		fmt.Println("timestamp:", resp)
+		applogger.Info("Get timestamp: %d", resp)
 	}
 }
diff --git a/cmd/crossmarginclientexample/crossmarginclientexample.go b/cmd/crossmarginclientexample/crossmarginclientexample.go
index 347ca31..fb93326 100644
--- a/cmd/crossmarginclientexample/crossmarginclientexample.go
+++ b/cmd/crossmarginclientexample/crossmarginclientexample.go
@@ -1,8 +1,8 @@
 package crossmarginclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
@@ -26,9 +26,9 @@ func transferIn() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.TransferIn(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -40,9 +40,9 @@ func transferOut() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.TransferOut(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -51,10 +51,10 @@ func getMarginLoanInfo() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetMarginLoanInfo()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, info := range resp {
-			fmt.Printf("Info: %+v \n", info)
+			applogger.Info("Info: %+v", info)
 		}
 	}
 }
@@ -66,9 +66,9 @@ func marginOrders() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.ApplyLoan(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -77,9 +77,11 @@ func marginOrdersRepay() {
 	orderId := "12345"
 	request := postrequest.MarginOrdersRepayRequest{Amount: "1.0"}
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
-	err := client.Repay(orderId, request)
+	resp, err := client.Repay(orderId, request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Repay error: %s", err)
+	} else {
+		applogger.Info("Repay successfully, id=%d", resp)
 	}
 }
 
@@ -89,10 +91,10 @@ func marginLoanOrders() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.MarginLoanOrders(optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, order := range resp {
-			fmt.Printf("Order: %+v\n", order)
+			applogger.Info("Order: %+v", order)
 		}
 	}
 }
@@ -102,10 +104,10 @@ func marginAccountsBalance() {
 	client := new(client.CrossMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.MarginAccountsBalance("")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, account := range resp.List {
-			fmt.Printf("Account: %+v\n", account)
+			applogger.Info("Account: %+v", account)
 		}
 	}
 }
diff --git a/cmd/etfclientexample/etfclientexample.go b/cmd/etfclientexample/etfclientexample.go
index 9cd8eb7..3d8e589 100644
--- a/cmd/etfclientexample/etfclientexample.go
+++ b/cmd/etfclientexample/etfclientexample.go
@@ -1,8 +1,8 @@
 package etfclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
 )
@@ -20,9 +20,9 @@ func getSwapConfig() {
 	currency := "hb10"
 	resp, err := client.GetSwapConfig(currency)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("EtfStatus: ", resp.EtfStatus, "PurchaseFeeRate: ", resp.PurchaseFeeRate)
+		applogger.Info("EtfStatus: %d, PurchaseFeeRate: %f", resp.EtfStatus, resp.PurchaseFeeRate)
 	}
 }
 
@@ -32,10 +32,10 @@ func getSwapList() {
 	currency := "hb10"
 	resp, err := client.GetSwapList(currency, 0, 10)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, result := range resp {
-			fmt.Printf("SwapList: %+v\n", result)
+			applogger.Info("SwapList: %+v", result)
 		}
 	}
 }
@@ -50,9 +50,9 @@ func swapIn() {
 	}
 	resp, err := client.SwapIn(swapRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("isSucceed: ", resp)
+		applogger.Info("isSucceed: %b", resp)
 	}
 }
 
@@ -66,8 +66,8 @@ func swapOut() {
 	}
 	resp, err := client.SwapOut(swapRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("isSucceed: ", resp)
+		applogger.Info("isSucceed: %b", resp)
 	}
 }
diff --git a/cmd/isolatedmarginclientexample/isolatedmarginclientexample.go b/cmd/isolatedmarginclientexample/isolatedmarginclientexample.go
index c4e71e7..4625dfa 100644
--- a/cmd/isolatedmarginclientexample/isolatedmarginclientexample.go
+++ b/cmd/isolatedmarginclientexample/isolatedmarginclientexample.go
@@ -1,8 +1,8 @@
 package isolatedmarginclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
@@ -27,9 +27,9 @@ func transferIn() {
 	client := new(client.IsolatedMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.TransferIn(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -42,9 +42,9 @@ func transferOut() {
 	client := new(client.IsolatedMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.TransferOut(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -54,11 +54,10 @@ func getMarginLoanInfo() {
 	client := new(client.IsolatedMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetMarginLoanInfo(optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, info := range resp {
-			fmt.Println("Symbol: ", info.Symbol)
-
+			applogger.Info("Symbol: %s", info.Symbol)
 		}
 	}
 }
@@ -73,9 +72,9 @@ func marginOrders() {
 	}
 	resp, err := client.Apply(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -86,9 +85,9 @@ func marginOrdersRepay() {
 	request := postrequest.MarginOrdersRepayRequest{Amount: "1.0"}
 	resp, err := client.Repay(orderId, request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Data: ", resp)
+		applogger.Info("Data: %+v", resp)
 	}
 }
 
@@ -100,10 +99,10 @@ func marginLoanOrders() {
 	}
 	resp, err := client.MarginLoanOrders("btcusdt", optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, order := range resp {
-			fmt.Println("Order: ", order)
+			applogger.Info("Order: %+v", order)
 		}
 	}
 }
@@ -115,12 +114,12 @@ func marginAccountsBalance() {
 	client := new(client.IsolatedMarginClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.MarginAccountsBalance(optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, account := range resp {
-			fmt.Println("Id: ", account.Id)
+			applogger.Info("Id: %d", account.Id)
 			for _, balance := range account.List {
-				fmt.Printf("Balance: %+v\n", balance)
+				applogger.Info("Balance: %+v", balance)
 			}
 		}
 	}
diff --git a/cmd/marketclientexample/marketclientexample.go b/cmd/marketclientexample/marketclientexample.go
index 616ce89..9a98c41 100644
--- a/cmd/marketclientexample/marketclientexample.go
+++ b/cmd/marketclientexample/marketclientexample.go
@@ -1,8 +1,8 @@
 package marketclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 )
@@ -24,10 +24,10 @@ func getCandlestick() {
 	optionalRequest := getrequest.GetCandlestickOptionalRequest{Period: getrequest.MIN1, Size: 10}
 	resp, err := client.GetCandlestick("btcusdt", optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, kline := range resp {
-			fmt.Println("High: ", kline.High, "Low:", kline.Low)
+			applogger.Info("High=%f, Low=%f", kline.High, kline.Low)
 		}
 	}
 }
@@ -38,9 +38,9 @@ func getLast24hCandlestickAskBid() {
 
 	resp, err := client.GetLast24hCandlestickAskBid("btcusdt")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Bid: ", resp.Bid, "Ask: ", resp.Ask)
+		applogger.Info("Bid=%+v, Ask=%+v", resp.Bid, resp.Ask)
 	}
 }
 
@@ -50,10 +50,10 @@ func getLast24hCandlesticks() {
 
 	resp, err := client.GetAllSymbolsLast24hCandlesticksAskBid()
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, tick := range resp {
-			fmt.Printf("Symbol: %s, High: %v, Low: %v, Ask[%v, %v], Bid[%v, %v]\n",
+			applogger.Info("Symbol: %s, High: %v, Low: %v, Ask[%v, %v], Bid[%v, %v]",
 				tick.Symbol, tick.High, tick.Low, tick.Ask, tick.AskSize, tick.Bid, tick.BidSize)
 		}
 	}
@@ -66,13 +66,13 @@ func getDepth() {
 
 	resp, err := client.GetDepth("btcusdt", getrequest.STEP0, optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, ask := range resp.Asks {
-			fmt.Println("ask: ", ask)
+			applogger.Info("ask: %+v", ask)
 		}
 		for _, bid := range resp.Bids {
-			fmt.Println("bid: ", bid)
+			applogger.Info("bid: %+v", bid)
 		}
 
 	}
@@ -84,10 +84,10 @@ func getLatestTrade() {
 
 	resp, err := client.GetLatestTrade("btcusdt")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, trade := range resp.Data {
-			fmt.Println("Id: ", trade.Id, "Price:", trade.Price)
+			applogger.Info("Id=%d, Price=%f", trade.Id, trade.Price)
 		}
 	}
 }
@@ -98,11 +98,11 @@ func getHistoricalTrade() {
 	optionalRequest := getrequest.GetHistoricalTradeOptionalRequest{5}
 	resp, err := client.GetHistoricalTrade("btcusdt", optionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		for _, tradeData := range resp {
 			for _, trade := range tradeData.Data {
-				fmt.Println("price: ", trade.Price)
+				applogger.Info("price: %f", trade.Price)
 			}
 		}
 	}
@@ -114,8 +114,8 @@ func getLast24hCandlestick() {
 
 	resp, err := client.GetLast24hCandlestick("btcusdt")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
-		fmt.Println("Close: ", resp.Close, "Open: ", resp.Open)
+		applogger.Info("Close=%f, Open=%f", resp.Close, resp.Open)
 	}
 }
diff --git a/cmd/marketwebsocketclientexample/marketwebsocketclientexample.go b/cmd/marketwebsocketclientexample/marketwebsocketclientexample.go
index 46dbb25..06918df 100644
--- a/cmd/marketwebsocketclientexample/marketwebsocketclientexample.go
+++ b/cmd/marketwebsocketclientexample/marketwebsocketclientexample.go
@@ -48,7 +48,7 @@ func reqAndSubscribeCandlestick() {
 					}
 				}
 			} else {
-				applogger.Info("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 
 		})
@@ -115,7 +115,7 @@ func reqAndSubscribeDepth() {
 					}
 				}
 			} else {
-				applogger.Error("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 
 		})
@@ -183,7 +183,7 @@ func reqAndSubscribeMarketByPrice() {
 					}
 				}
 			} else {
-				applogger.Error("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 
 		})
@@ -230,7 +230,7 @@ func subscribeFullMarketByPrice() {
 					}
 				}
 			} else {
-				applogger.Error("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 
 		})
@@ -306,7 +306,7 @@ func reqAndSubscribeTrade() {
 					}
 				}
 			} else {
-				applogger.Error("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 
 		})
@@ -352,7 +352,7 @@ func reqAndSubscribeLast24hCandlestick() {
 					}
 				}
 			} else {
-				applogger.Error("Unknown response: %v", resp)
+				applogger.Warn("Unknown response: %v", resp)
 			}
 		})
 
diff --git a/cmd/orderclientexample/orderclientexample.go b/cmd/orderclientexample/orderclientexample.go
index 92c5eff..715b4f7 100644
--- a/cmd/orderclientexample/orderclientexample.go
+++ b/cmd/orderclientexample/orderclientexample.go
@@ -1,8 +1,8 @@
 package orderclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
@@ -37,13 +37,13 @@ func placeOrder() {
 	}
 	resp, err := client.PlaceOrder(&request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
-			fmt.Printf("Place order successfully, order id: %s\n", resp.Data)
+			applogger.Info("Place order successfully, order id: %s", resp.Data)
 		case "error":
-			fmt.Printf("Place order error: %s\n", resp.ErrorMessage)
+			applogger.Error("Place order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -64,21 +64,21 @@ func placeOrders() {
 	requests = append(requests, request)
 	resp, err := client.PlaceOrders(requests)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, r := range resp.Data {
 					if r.OrderId != 0 {
-						fmt.Printf("Place order successfully: order id %d\n", r.OrderId)
+						applogger.Info("Place order successfully: order id %d", r.OrderId)
 					} else {
-						fmt.Printf("Place order error: %s\n", r.ErrorMessage)
+						applogger.Info("Place order error: %s", r.ErrorMessage)
 					}
 				}
 			}
 		case "error":
-			fmt.Printf("Place order error: %s", resp.ErrorMessage)
+			applogger.Error("Place order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -87,13 +87,13 @@ func cancelOrderById() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.CancelOrderById("1")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
-			fmt.Printf("Cancel order successfully, order id: %s\n", resp.Data)
+			applogger.Info("Cancel order successfully, order id: %s", resp.Data)
 		case "error":
-			fmt.Printf("Cancel order error: %s\n", resp.ErrorMessage)
+			applogger.Info("Cancel order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -102,13 +102,13 @@ func cancelOrderByClient() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.CancelOrderByClientOrderId("1")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
-			fmt.Printf("Cancel order successfully, order id: %d\n", resp.Data)
+			applogger.Info("Cancel order successfully, order id: %d", resp.Data)
 		case "error":
-			fmt.Printf("Cancel order error: %s\n", resp.ErrorMessage)
+			applogger.Info("Cancel order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -120,18 +120,18 @@ func getOpenOrders() {
 	request.AddParam("symbol", "btcusdt")
 	resp, err := client.GetOpenOrders(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, o := range resp.Data {
-					fmt.Printf("Open orders, symbol: %s, price: %s, amount: %s\n", o.Symbol, o.Price, o.Amount)
+					applogger.Info("Open orders, symbol: %s, price: %s, amount: %s", o.Symbol, o.Price, o.Amount)
 				}
-				fmt.Printf("There are total %d open orders\n", len(resp.Data))
+				applogger.Info("There are total %d open orders", len(resp.Data))
 			}
 		case "error":
-			fmt.Printf("Get open order error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get open order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -145,16 +145,16 @@ func cancelOrdersByCriteria() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.CancelOrdersByCriteria(&request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				d := resp.Data
-				fmt.Printf("Cancel orders successfully, success count: %d, failed count: %d, next id: %d\n", d.SuccessCount, d.FailedCount, d.NextId)
+				applogger.Info("Cancel orders successfully, success count: %d, failed count: %d, next id: %d", d.SuccessCount, d.FailedCount, d.NextId)
 			}
 		case "error":
-			fmt.Printf("Cancel orders error: %s\n", resp.ErrorMessage)
+			applogger.Error("Cancel orders error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -167,14 +167,14 @@ func cancelOrdersByIds() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.CancelOrdersByIds(&request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				if resp.Data.Success != nil {
 					for _, id := range resp.Data.Success {
-						fmt.Printf("Cancel orders successfully, id: %s\n", id)
+						applogger.Info("Cancel orders successfully, id: %s", id)
 					}
 				}
 				if resp.Data.Failed != nil {
@@ -183,12 +183,12 @@ func cancelOrdersByIds() {
 						if id == "" {
 							id = f.ClientOrderId
 						}
-						fmt.Printf("Cancel orders failed, id: %s, error: %s\n", id, f.ErrorMessage)
+						applogger.Error("Cancel orders failed, id: %s, error: %s", id, f.ErrorMessage)
 					}
 				}
 			}
 		case "error":
-			fmt.Printf("Cancel orders error: %s\n", resp.ErrorMessage)
+			applogger.Error("Cancel orders error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -197,17 +197,17 @@ func getOrderById() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetOrderById("1")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				o := resp.Data
-				fmt.Printf("Get order, symbol: %s, price: %s, amount: %s, filled amount: %s, filled cash amount: %s, filled fees: %s\n",
+				applogger.Info("Get order, symbol: %s, price: %s, amount: %s, filled amount: %s, filled cash amount: %s, filled fees: %s",
 					o.Symbol, o.Price, o.Amount, o.FilledAmount, o.FilledCashAmount, o.FilledFees)
 			}
 		case "error":
-			fmt.Printf("Get order by id error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get order by id error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -218,17 +218,17 @@ func getOrderByCriteria() {
 	request.AddParam("clientOrderId", "cid12345")
 	resp, err := client.GetOrderByCriteria(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				o := resp.Data
-				fmt.Printf("Get order, symbol: %s, price: %s, amount: %s, filled amount: %s, filled cash amount: %s, filled fees: %s\n",
+				applogger.Info("Get order, symbol: %s, price: %s, amount: %s, filled amount: %s, filled cash amount: %s, filled fees: %s",
 					o.Symbol, o.Price, o.Amount, o.FilledAmount, o.FilledCashAmount, o.FilledFees)
 			}
 		case "error":
-			fmt.Printf("Get order by criteria error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get order by criteria error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -237,18 +237,18 @@ func getMatchResultById() {
 	client := new(client.OrderClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.GetMatchResultsById("63403286375")
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, r := range resp.Data {
-					fmt.Printf("Match result, symbol: %s, filled amount: %s, filled fees: %s\n", r.Symbol, r.FilledAmount, r.FilledFees)
+					applogger.Info("Match result, symbol: %s, filled amount: %s, filled fees: %s", r.Symbol, r.FilledAmount, r.FilledFees)
 				}
-				fmt.Printf("There are total %d match results\n", len(resp.Data))
+				applogger.Info("There are total %d match results", len(resp.Data))
 			}
 		case "error":
-			fmt.Printf("Get match results error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get match results error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -260,18 +260,18 @@ func getHistoryOrders() {
 	request.AddParam("states", "canceled")
 	resp, err := client.GetHistoryOrders(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, o := range resp.Data {
-					fmt.Printf("Order history, symbol: %s, price: %s, amount: %s, state: %s\n", o.Symbol, o.Price, o.Amount, o.State)
+					applogger.Info("Order history, symbol: %s, price: %s, amount: %s, state: %s", o.Symbol, o.Price, o.Amount, o.State)
 				}
-				fmt.Printf("There are total %d orders\n", len(resp.Data))
+				applogger.Info("There are total %d orders", len(resp.Data))
 			}
 		case "error":
-			fmt.Printf("Get history order error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get history order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -282,18 +282,18 @@ func getLast48hOrders() {
 	request.AddParam("symbol", "btcusdt")
 	resp, err := client.GetLast48hOrders(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, o := range resp.Data {
-					fmt.Printf("Order history, symbol: %s, price: %s, amount: %s, state: %s\n", o.Symbol, o.Price, o.Amount, o.State)
+					applogger.Info("Order history, symbol: %s, price: %s, amount: %s, state: %s", o.Symbol, o.Price, o.Amount, o.State)
 				}
-				fmt.Printf("There are total %d orders\n", len(resp.Data))
+				applogger.Info("There are total %d orders", len(resp.Data))
 			}
 		case "error":
-			fmt.Printf("Get history order error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get history order error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -304,18 +304,18 @@ func getMatchResultByCriteria() {
 	request.AddParam("symbol", "btcusdt")
 	resp, err := client.GetMatchResultsByCriteria(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Status {
 		case "ok":
 			if resp.Data != nil {
 				for _, r := range resp.Data {
-					fmt.Printf("Match result, symbol: %s, filled amount: %s, filled fees: %s\n", r.Symbol, r.FilledAmount, r.FilledFees)
+					applogger.Info("Match result, symbol: %s, filled amount: %s, filled fees: %s", r.Symbol, r.FilledAmount, r.FilledFees)
 				}
-				fmt.Printf("There are total %d match results\n", len(resp.Data))
+				applogger.Info("There are total %d match results", len(resp.Data))
 			}
 		case "error":
-			fmt.Printf("Get match results error: %s\n", resp.ErrorMessage)
+			applogger.Error("Get match results error: %s", resp.ErrorMessage)
 		}
 	}
 }
@@ -326,19 +326,19 @@ func getTransactFeeRate() {
 	request.AddParam("symbols", "btcusdt,eosht")
 	resp, err := client.GetTransactFeeRate(request)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error(err.Error())
 	} else {
 		switch resp.Code {
 		case 200:
 			if resp.Data != nil {
 				for _, f := range resp.Data {
-					fmt.Printf("Fee rate , symbol: %s, maker-taker fee: %s-%s, actual maker-taker fee: %s-%s\n",
+					applogger.Info("Fee rate , symbol: %s, maker-taker fee: %s-%s, actual maker-taker fee: %s-%s",
 						f.Symbol, f.MakerFeeRate, f.TakerFeeRate, f.ActualMakerRate, f.ActualTakerRate)
 				}
-				fmt.Printf("There are total %d fee rate result\n", len(resp.Data))
+				applogger.Info("There are total %d fee rate result", len(resp.Data))
 			}
 		default:
-			fmt.Printf("Get fee error: %s\n", resp.Message)
+			applogger.Error("Get fee error: %s", resp.Message)
 		}
 	}
 }
diff --git a/cmd/orderwebsocketclientexample/orderwebsocketclientexample.go b/cmd/orderwebsocketclientexample/orderwebsocketclientexample.go
index 6c027d7..3827500 100644
--- a/cmd/orderwebsocketclientexample/orderwebsocketclientexample.go
+++ b/cmd/orderwebsocketclientexample/orderwebsocketclientexample.go
@@ -25,12 +25,12 @@ func reqOrderV1() {
 			if resp.ErrorCode == 0 {
 				err := client.Request("1", "1601")
 				if err != nil {
-					fmt.Printf("Request error: %s\n", err)
+					applogger.Error("Request error: %s", err)
 				} else {
-					fmt.Println("Sent request")
+					applogger.Debug("Sent request")
 				}
 			} else {
-				fmt.Printf("Authentication error: %d\n", resp.ErrorCode)
+				applogger.Error("Authentication error: %d", resp.ErrorCode)
 			}
 
 		},
@@ -39,18 +39,18 @@ func reqOrderV1() {
 			if ok {
 				if &reqResponse.Data != nil {
 					o := reqResponse.Data
-					fmt.Printf("Request order, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.Id, o.State, o.Symbol, o.Price, o.FilledAmount)
+					applogger.Info("Request order, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.Id, o.State, o.Symbol, o.Price, o.FilledAmount)
 				} else {
-					fmt.Printf("Request order error: %s", reqResponse.ErrorCode)
+					applogger.Error("Request order error: %s", reqResponse.ErrorCode)
 				}
 			} else {
-				fmt.Printf("Received unknown response: %v\n", resp)
+				applogger.Warn("Received unknown response: %v", resp)
 			}
 		})
 
 	err := client.Connect(true)
 	if err != nil {
-		fmt.Printf("Client Connect error: %s\n", err)
+		applogger.Error("Client Connect error: %s", err)
 		return
 	}
 
@@ -58,7 +58,7 @@ func reqOrderV1() {
 	fmt.Scanln()
 
 	client.Close()
-	fmt.Println("Client closed")
+	applogger.Info("Client closed")
 }
 
 func reqOrdersV1() {
@@ -73,12 +73,12 @@ func reqOrdersV1() {
 				}
 				err := client.Request(req)
 				if err != nil {
-					fmt.Printf("Request error: %s\n", err)
+					applogger.Error("Request error: %s", err)
 				} else {
-					fmt.Println("Sent request")
+					applogger.Debug("Sent request")
 				}
 			} else {
-				fmt.Printf("Authentication error: %d\n", resp.ErrorCode)
+				applogger.Error("Authentication error: %d", resp.ErrorCode)
 			}
 
 		},
@@ -87,19 +87,19 @@ func reqOrdersV1() {
 			if ok {
 				if &reqResponse.Data != nil {
 					for _, o := range reqResponse.Data {
-						fmt.Printf("Request order, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.Id, o.State, o.Symbol, o.Price, o.FilledAmount)
+						applogger.Info("Request order, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.Id, o.State, o.Symbol, o.Price, o.FilledAmount)
 					}
 				} else {
-					fmt.Printf("Request order error: %s", reqResponse.ErrorCode)
+					applogger.Error("Request order error: %s", reqResponse.ErrorCode)
 				}
 			} else {
-				fmt.Printf("Received unknown response: %v\n", resp)
+				applogger.Warn("Received unknown response: %+v", resp)
 			}
 		})
 
 	err := client.Connect(true)
 	if err != nil {
-		fmt.Printf("Client Connect error: %s\n", err)
+		applogger.Error("Client Connect error: %s", err)
 		return
 	}
 
@@ -107,7 +107,7 @@ func reqOrdersV1() {
 	fmt.Scanln()
 
 	client.Close()
-	fmt.Println("Client closed")
+	applogger.Info("Client closed")
 }
 
 func subOrderUpdateV1() {
@@ -121,12 +121,12 @@ func subOrderUpdateV1() {
 			if resp.ErrorCode == 0 {
 				err := client.Subscribe("btcusdt", "1601")
 				if err != nil {
-					fmt.Printf("Subscribe error: %s\n", err)
+					applogger.Error("Subscribe error: %s", err)
 				} else {
-					fmt.Println("Sent subscription")
+					applogger.Debug("Sent subscription")
 				}
 			} else {
-				fmt.Printf("Authentication error: %d\n", resp.ErrorCode)
+				applogger.Error("Authentication error: %d", resp.ErrorCode)
 			}
 
 		},
@@ -136,17 +136,17 @@ func subOrderUpdateV1() {
 			if ok {
 				if &subResponse.Data != nil {
 					o := subResponse.Data
-					fmt.Printf("Order update, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.OrderId, o.OrderState, o.Symbol, o.Price, o.FilledAmount)
+					applogger.Info("Order update, id: %d, state: %s, symbol: %s, price: %s, filled amount: %s", o.OrderId, o.OrderState, o.Symbol, o.Price, o.FilledAmount)
 				}
 			} else {
-				fmt.Printf("Received unknown response: %v\n", resp)
+				applogger.Warn("Received unknown response: %+v", resp)
 			}
 		})
 
 	// Connect to the server and wait for the handler to handle the response
 	err := client.Connect(true)
 	if err != nil {
-		fmt.Printf("Client Connect error: %s\n", err)
+		applogger.Error("Client Connect error: %s", err)
 		return
 	}
 
@@ -155,11 +155,11 @@ func subOrderUpdateV1() {
 
 	err = client.UnSubscribe("1", "1250")
 	if err != nil {
-		fmt.Printf("UnSubscribe error: %s\n", err)
+		applogger.Error("UnSubscribe error: %s", err)
 	}
 
 	client.Close()
-	fmt.Println("Client closed")
+	applogger.Info("Client closed")
 }
 
 func subOrderUpdateV2() {
@@ -195,7 +195,7 @@ func subOrderUpdateV2() {
 					}
 				}
 			} else {
-				applogger.Error("Received unknown response: %v", resp)
+				applogger.Warn("Received unknown response: %v", resp)
 			}
 		})
 
@@ -244,7 +244,7 @@ func subTradeClear() {
 					}
 				}
 			} else {
-				applogger.Error("Received unknown response: %v", resp)
+				applogger.Warn("Received unknown response: %v", resp)
 			}
 		})
 
diff --git a/cmd/traderexample/traderexample.go b/cmd/traderexample/traderexample.go
index 0a258e7..fb236e7 100644
--- a/cmd/traderexample/traderexample.go
+++ b/cmd/traderexample/traderexample.go
@@ -3,6 +3,7 @@ package traderexample
 import (
 	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client/marketwebsocketclient"
 	"github.com/huobirdcenter/huobi_golang/pkg/response/market"
 )
@@ -29,7 +30,7 @@ func subMultipleBBO() {
 			if ok {
 				if bboResponse.Tick != nil {
 					t := bboResponse.Tick
-					fmt.Printf("Received update, symbol: %s, ask: [%v, %v], bid: [%v, %v]\n", t.Symbol, t.Ask, t.AskSize, t.Bid, t.BidSize)
+					applogger.Info("Received update, symbol: %s, ask: [%v, %v], bid: [%v, %v]", t.Symbol, t.Ask, t.AskSize, t.Bid, t.BidSize)
 				}
 			}
 
@@ -41,5 +42,5 @@ func subMultipleBBO() {
 	fmt.Scanln()
 
 	client.Close()
-	fmt.Println("Connection closed")
+	applogger.Info("Connection closed")
 }
\ No newline at end of file
diff --git a/cmd/walletclientexample/walletclientexample.go b/cmd/walletclientexample/walletclientexample.go
index 7e75437..6258ace 100644
--- a/cmd/walletclientexample/walletclientexample.go
+++ b/cmd/walletclientexample/walletclientexample.go
@@ -1,8 +1,8 @@
 package walletclientexample
 
 import (
-	"fmt"
 	"github.com/huobirdcenter/huobi_golang/config"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/client"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
 	"github.com/huobirdcenter/huobi_golang/pkg/postrequest"
@@ -10,39 +10,53 @@ import (
 
 func RunAllExamples() {
 	getDepositAddress()
+	getSubUserDepositAddress()
 	getWithdrawQuota()
 	createWithdraw()
 	cancelWithdraw()
 	queryDepositWithdraw()
+	querySubUserDepositHistory()
 }
 
-//  Get deposit address of corresponding chain, for a specific crypto currency (except IOTA)
 func getDepositAddress() {
 	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	currency := "usdt"
 	resp, err := client.GetDepositAddress(currency)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get deposit address error: %s", err)
 	} else {
+		applogger.Info("Get deposit address, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("DepositAddress: %+v\n", result)
+			applogger.Info("DepositAddress: %+v", result)
+		}
+	}
+}
+
+func getSubUserDepositAddress() {
+	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
+	currency := "usdt"
+	resp, err := client.GetSubUserDepositAddress(config.SubUid, currency)
+	if err != nil {
+		applogger.Error("Get sub user deposit address error: %s", err)
+	} else {
+		applogger.Info("Get sub user deposit address, count=%d", len(resp))
+		for _, result := range resp {
+			applogger.Info("DepositAddress: %+v", result)
 		}
 	}
 }
 
-//  Get the withdraw quota for currencies
 func getWithdrawQuota() {
 	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	currency := "usdt"
 	resp, err := client.GetWithdrawQuota(currency)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Get withdraw quota error: %s", err)
 	} else {
-		fmt.Println("Currency: ", resp.Currency, "Chain: ", resp.Chains[0].Chain, "MaxWithdrawAmt: ", resp.Chains[0].MaxWithdrawAmt)
+		applogger.Info("Currency: %s, Chain: %s, MaxWithdrawAmt: %s", resp.Currency, resp.Chains[0].Chain, resp.Chains[0].MaxWithdrawAmt)
 	}
 }
 
-//  Create a withdraw request from your spot trading account to an external address.
 func createWithdraw() {
 	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	createWithdrawRequest := postrequest.CreateWithdrawRequest{
@@ -52,35 +66,47 @@ func createWithdraw() {
 		Fee:      "1.0"}
 	resp, err := client.CreateWithdraw(createWithdrawRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Create withdraw request error: %s", err)
 	} else {
-		fmt.Println(resp)
+		applogger.Info("Create withdraw request successfully: id=%d", resp)
 	}
 }
 
-//  Cancel a previously created withdraw request by its transfer id.
 func cancelWithdraw() {
 	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	resp, err := client.CancelWithdraw(12345)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Cancel withdraw error: %s", err)
 	} else {
-		fmt.Println(resp)
+		applogger.Info("Cancel withdraw successfully: id=%d", resp)
 	}
 }
 
-//  Get all existed withdraws and deposits and return their latest status.
 func queryDepositWithdraw() {
 	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
 	depositType := "deposit"
 	queryDepositWithdrawOptionalRequest := getrequest.QueryDepositWithdrawOptionalRequest{Currency: "usdt"}
 	resp, err := client.QueryDepositWithdraw(depositType, queryDepositWithdrawOptionalRequest)
 	if err != nil {
-		fmt.Println(err)
+		applogger.Error("Query deposit-withdraw history error: %s", err)
+	} else {
+		applogger.Info("Query deposit-withdraw history, count=%d", len(resp))
+		for _, result := range resp {
+			applogger.Info("resp: %+v", result)
+		}
+	}
+}
+
+func querySubUserDepositHistory() {
+	client := new(client.WalletClient).Init(config.AccessKey, config.SecretKey, config.Host)
+	optionalRequest := getrequest.QuerySubUserDepositHistoryOptionalRequest{Currency: "usdt"}
+	resp, err := client.QuerySubUserDepositHistory(config.SubUid, optionalRequest)
+	if err != nil {
+		applogger.Error("Query sub user deposit history error: %s", err)
 	} else {
+		applogger.Info("Query sub user deposit history, count=%d", len(resp))
 		for _, result := range resp {
-			fmt.Printf("resp: %+v\n", result)
+			applogger.Info("resp: %+v", result)
 		}
-		fmt.Printf("There are total %d deposit-withdraw history", len(resp))
 	}
 }
diff --git a/pkg/client/accountclient.go b/pkg/client/accountclient.go
index aa6b03b..f687606 100644
--- a/pkg/client/accountclient.go
+++ b/pkg/client/accountclient.go
@@ -3,6 +3,7 @@ package client
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"github.com/huobirdcenter/huobi_golang/internal"
 	"github.com/huobirdcenter/huobi_golang/internal/requestbuilder"
 	"github.com/huobirdcenter/huobi_golang/pkg/getrequest"
@@ -194,7 +195,6 @@ func (p *AccountClient) SubUserTransfer(request postrequest.SubUserTransferReque
 
 // Returns the aggregated balance from all the sub-users
 func (p *AccountClient) GetSubUserAggregateBalance() ([]account.Balance, error) {
-
 	url := p.privateUrlBuilder.Build("GET", "/v1/subuser/aggregate-balance", nil)
 	getResp, getErr := internal.HttpGet(url)
 	if getErr != nil {
@@ -215,8 +215,7 @@ func (p *AccountClient) GetSubUserAggregateBalance() ([]account.Balance, error)
 
 // Returns the balance of a sub-account specified by sub-uid
 func (p *AccountClient) GetSubUserAccount(subUid int64) ([]account.SubUserAccount, error) {
-
-	url := p.privateUrlBuilder.Build("GET", "/v1/account/accounts/"+strconv.FormatInt(subUid, 10), nil)
+	url := p.privateUrlBuilder.Build("GET", fmt.Sprintf("/v1/account/accounts/%d", subUid), nil)
 	getResp, getErr := internal.HttpGet(url)
 	if getErr != nil {
 		return nil, getErr
@@ -227,7 +226,6 @@ func (p *AccountClient) GetSubUserAccount(subUid int64) ([]account.SubUserAccoun
 		return nil, jsonErr
 	}
 	if result.Status == "ok" && result.Data != nil {
-
 		return result.Data, nil
 	}
 
diff --git a/pkg/client/crossmarginclient.go b/pkg/client/crossmarginclient.go
index c3318c5..3e7594a 100644
--- a/pkg/client/crossmarginclient.go
+++ b/pkg/client/crossmarginclient.go
@@ -122,28 +122,28 @@ func (p *CrossMarginClient) ApplyLoan(request postrequest.CrossMarginOrdersReque
 }
 
 // Repays margin loan with you asset in your margin account.
-func (p *CrossMarginClient) Repay(orderId string, request postrequest.MarginOrdersRepayRequest) error {
+func (p *CrossMarginClient) Repay(orderId string, request postrequest.MarginOrdersRepayRequest) (int, error) {
 	postBody, jsonErr := postrequest.ToJson(request)
 	if jsonErr != nil {
-		return jsonErr
+		return 0, jsonErr
 	}
 
 	url := p.privateUrlBuilder.Build("POST", "/v1/cross-margin/orders/"+orderId+"/repay", nil)
 	postResp, postErr := internal.HttpPost(url, postBody)
 	if postErr != nil {
-		return postErr
+		return 0, postErr
 	}
 
 	result := margin.MarginOrdersRepayResponse{}
 	jsonErr = json.Unmarshal([]byte(postResp), &result)
 	if jsonErr != nil {
-		return jsonErr
+		return 0, jsonErr
 	}
 	if result.Status != "ok" {
-		return errors.New(postResp)
+		return 0, errors.New(postResp)
 
 	}
-	return nil
+	return result.Data, nil
 }
 
 // Returns margin orders based on a specific searching criteria.
diff --git a/pkg/client/walletclient.go b/pkg/client/walletclient.go
index c0ca4e8..455582e 100644
--- a/pkg/client/walletclient.go
+++ b/pkg/client/walletclient.go
@@ -45,6 +45,29 @@ func (p *WalletClient) GetDepositAddress(currency string) ([]wallet.DepositAddre
 	return nil, errors.New(getResp)
 }
 
+// Parent user query sub user deposit address of corresponding chain, for a specific crypto currency (except IOTA)
+func (p *WalletClient) GetSubUserDepositAddress(subUid int64, currency string) ([]wallet.DepositAddress, error) {
+	request := new(getrequest.GetRequest).Init()
+	request.AddParam("subUid", strconv.FormatInt(subUid, 10))
+	request.AddParam("currency", currency)
+
+	url := p.privateUrlBuilder.Build("GET", "/v2/sub-user/deposit-address", request)
+	getResp, getErr := internal.HttpGet(url)
+	if getErr != nil {
+		return nil, getErr
+	}
+
+	result := wallet.GetDepositAddressResponse{}
+	jsonErr := json.Unmarshal([]byte(getResp), &result)
+	if jsonErr != nil {
+		return nil, jsonErr
+	}
+	if result.Code == 200 && result.Data != nil {
+		return result.Data, nil
+	}
+	return nil, errors.New(getResp)
+}
+
 // Query withdraw quota for currencies
 func (p *WalletClient) GetWithdrawQuota(currency string) (*wallet.WithdrawQuota, error) {
 	request := new(getrequest.GetRequest).Init()
@@ -146,3 +169,45 @@ func (p *WalletClient) QueryDepositWithdraw(depositOrWithdraw string, optionalRe
 	}
 	return nil, errors.New(getResp)
 }
+
+// Parent user query sub user deposits history
+func (p *WalletClient) QuerySubUserDepositHistory(subUid int64, optionalRequest getrequest.QuerySubUserDepositHistoryOptionalRequest) ([]wallet.DepositHistory, error) {
+	request := new(getrequest.GetRequest).Init()
+
+	request.AddParam("subUid", strconv.FormatInt(subUid, 10))
+
+	if optionalRequest.Currency != "" {
+		request.AddParam("currency", optionalRequest.Currency)
+	}
+	if optionalRequest.StartTime != 0 {
+		request.AddParam("startTime", strconv.FormatInt(optionalRequest.StartTime, 10))
+	}
+	if optionalRequest.EndTime != 0 {
+		request.AddParam("endTime", strconv.FormatInt(optionalRequest.EndTime, 10))
+	}
+	if optionalRequest.Sort != "" {
+		request.AddParam("sort", optionalRequest.Sort)
+	}
+	if optionalRequest.Limit != "" {
+		request.AddParam("limit", optionalRequest.Limit)
+	}
+	if optionalRequest.FromId != 0 {
+		request.AddParam("fromId", strconv.FormatInt(optionalRequest.FromId, 10))
+	}
+
+	url := p.privateUrlBuilder.Build("GET", "/v2/sub-user/query-deposit", request)
+	getResp, getErr := internal.HttpGet(url)
+	if getErr != nil {
+		return nil, getErr
+	}
+
+	result := wallet.QuerySubUserDepositHistoryResponse{}
+	jsonErr := json.Unmarshal([]byte(getResp), &result)
+	if jsonErr != nil {
+		return nil, jsonErr
+	}
+	if result.Code == 200 && result.Data != nil {
+		return result.Data, nil
+	}
+	return nil, errors.New(getResp)
+}
\ No newline at end of file
diff --git a/pkg/client/websocketclientbase/websocketv1clientbase.go b/pkg/client/websocketclientbase/websocketv1clientbase.go
index 91c2577..2bc988d 100644
--- a/pkg/client/websocketclientbase/websocketv1clientbase.go
+++ b/pkg/client/websocketclientbase/websocketv1clientbase.go
@@ -7,6 +7,7 @@ import (
 	"github.com/huobirdcenter/huobi_golang/internal/gzip"
 	"github.com/huobirdcenter/huobi_golang/internal/model"
 	"github.com/huobirdcenter/huobi_golang/internal/requestbuilder"
+	"github.com/huobirdcenter/huobi_golang/logging/applogger"
 	"github.com/huobirdcenter/huobi_golang/pkg/response/auth"
 	"strings"
 	"sync"
@@ -92,12 +93,12 @@ func (p *WebSocketV1ClientBase) Close() {
 func (p *WebSocketV1ClientBase) connectWebSocket() error {
 	var err error
 	url := fmt.Sprintf("wss://%s%s", p.host, websocketV1Path)
-	fmt.Println("WebSocket connecting...")
+	applogger.Debug("WebSocket connecting...")
 	p.conn, _, err = websocket.DefaultDialer.Dial(url, nil)
 	if err != nil {
 		return err
 	}
-	fmt.Println("WebSocket connected")
+	applogger.Info("WebSocket connected")
 
 	auth, err := p.requestBuilder.Build()
 	if err != nil {
@@ -121,14 +122,14 @@ func (p *WebSocketV1ClientBase) disconnectWebSocket() {
 
 	p.stopReadLoop()
 
-	fmt.Println("WebSocket disconnecting...")
+	applogger.Info("WebSocket disconnecting...")
 	err := p.conn.Close()
 	if err != nil {
-		fmt.Printf("WebSocket disconnect error: %s\n", err)
+		applogger.Error("WebSocket disconnect error: %s", err)
 		return
 	}
 
-	fmt.Println("WebSocket disconnected")
+	applogger.Info("WebSocket disconnected")
 }
 
 // initialize a ticker and start a goroutine tickerLoop()
@@ -155,20 +156,20 @@ func (p *WebSocketV1ClientBase) tickerLoop() {
 		select {
 		// Receive data from stopChannel
 		case <-p.stopTickerChannel:
-			fmt.Println("tickerLoop stopped")
+			applogger.Debug("tickerLoop stopped")
 			return
 
 		// Receive tick from tickChannel
 		case <-p.ticker.C:
 			elapsedSecond := time.Now().Sub(p.lastReceivedTime).Seconds()
-			fmt.Printf("WebSocket received data %f sec ago\n", elapsedSecond)
+			applogger.Debug("WebSocket received data %f sec ago", elapsedSecond)
 
 			if elapsedSecond > ReconnectWaitSecond {
-				fmt.Println("WebSocket reconnect...")
+				applogger.Info("WebSocket reconnect...")
 				p.disconnectWebSocket()
 				err := p.connectWebSocket()
 				if err != nil {
-					fmt.Printf("WebSocket reconnect error: %s\n", err)
+					applogger.Error("WebSocket reconnect error: %s", err)
 				}
 			}
 		}
@@ -192,19 +193,19 @@ func (p *WebSocketV1ClientBase) readLoop() {
 		select {
 		// Receive data from stopChannel
 		case <-p.stopReadChannel:
-			fmt.Println("readLoop stopped")
+			applogger.Debug("readLoop stopped")
 			return
 
 		default:
 			if p.conn == nil {
-				fmt.Printf("Read error: no connection available")
+				applogger.Error("Read error: no connection available")
 				time.Sleep(TimerIntervalSecond * time.Second)
 				continue
 			}
 
 			msgType, buf, err := p.conn.ReadMessage()
 			if err != nil {
-				fmt.Printf("Read error: %s\n", err)
+				applogger.Error("Read error: %s", err)
 				time.Sleep(TimerIntervalSecond * time.Second)
 				continue
 			}
@@ -215,17 +216,17 @@ func (p *WebSocketV1ClientBase) readLoop() {
 			if msgType == websocket.BinaryMessage {
 				message, err := gzip.GZipDecompress(buf)
 				if err != nil {
-					fmt.Printf("UnGZip data error: %s\n", err)
+					applogger.Error("UnGZip data error: %s", err)
 				}
 
 				// Try to pass as PingV1Message
 				// If it is Ping then respond Pong
 				pingV1Msg := model.ParsePingV1Message(message)
 				if pingV1Msg.IsPing() {
-					fmt.Printf("Received Ping: %d\n", pingV1Msg.Timestamp)
+					applogger.Debug("Received Ping: %d", pingV1Msg.Timestamp)
 					pongMsg := fmt.Sprintf("{\"op\": \"pong\", \"ts\": %d}", pingV1Msg.Timestamp)
 					p.Send(pongMsg)
-					fmt.Printf("Respond  Pong: %d\n", pingV1Msg.Timestamp)
+					applogger.Debug("Respond  Pong: %d", pingV1Msg.Timestamp)
 				} else {
 					// Try to pass as websocket v1 authentication response
 					// If it is then invoke authentication handler
@@ -238,7 +239,7 @@ func (p *WebSocketV1ClientBase) readLoop() {
 						// If it contains expected string, then invoke message handler and response handler
 						result, err := p.messageHandler(message)
 						if err != nil {
-							fmt.Printf("Handle message error: %s\n", err)
+							applogger.Error("Handle message error: %s", err)
 							continue
 						}
 						if p.responseHandler != nil {
diff --git a/pkg/client/websocketclientbase/websocketv2clientbase.go b/pkg/client/websocketclientbase/websocketv2clientbase.go
index 8b380c7..ec685ef 100644
--- a/pkg/client/websocketclientbase/websocketv2clientbase.go
+++ b/pkg/client/websocketclientbase/websocketv2clientbase.go
@@ -197,9 +197,7 @@ func (p *WebSocketV2ClientBase) readLoop() {
 				continue
 			}
 
-			applogger.Debug("Reading...")
 			msgType, buf, err := p.conn.ReadMessage()
-			applogger.Debug("Reading done")
 			if err != nil {
 				applogger.Error("Read error: %s", err)
 				time.Sleep(TimerIntervalSecond * time.Second)
diff --git a/pkg/getrequest/querysubuserdeposithistoryoptionalrequest.go b/pkg/getrequest/querysubuserdeposithistoryoptionalrequest.go
new file mode 100644
index 0000000..4b73815
--- /dev/null
+++ b/pkg/getrequest/querysubuserdeposithistoryoptionalrequest.go
@@ -0,0 +1,10 @@
+package getrequest
+
+type QuerySubUserDepositHistoryOptionalRequest struct {
+	Currency  string `json:"currency"`
+	StartTime int64  `json:"startTime"`
+	EndTime   int64  `json:"endTime"`
+	Sort      string `json:"sort"`
+	Limit     string `json:"limit"`
+	FromId    int64  `json:"fromId"`
+}
diff --git a/pkg/response/market/getlatesttraderesponse.go b/pkg/response/market/getlatesttraderesponse.go
index f666210..d0c4d7c 100644
--- a/pkg/response/market/getlatesttraderesponse.go
+++ b/pkg/response/market/getlatesttraderesponse.go
@@ -15,7 +15,7 @@ type TradeTick struct {
 		Amount    decimal.Decimal `json:"amount"`
 		TradeId   int64           `json:"trade-id"`
 		Ts        int64           `json:"ts"`
-		Id        decimal.Decimal `json:"id"`
+		Id        int64           `json:"id"`
 		Price     decimal.Decimal `json:"price"`
 		Direction string          `json:"direction"`
 	}
diff --git a/pkg/response/wallet/querysubuserdeposithistoryresponse.go b/pkg/response/wallet/querysubuserdeposithistoryresponse.go
new file mode 100644
index 0000000..787541e
--- /dev/null
+++ b/pkg/response/wallet/querysubuserdeposithistoryresponse.go
@@ -0,0 +1,23 @@
+package wallet
+
+import "github.com/shopspring/decimal"
+
+type QuerySubUserDepositHistoryResponse struct {
+	Code    int             `json:"code"`
+	Message string          `json:"message"`
+	Data    []DepositHistory `json:"data"`
+	NextId  int64           `json:"nextId"`
+}
+
+type DepositHistory struct {
+	Id              int64           `json:"id"`
+	Currency        string          `json:"currency"`
+	TransactionHash string          `json:"txHash"`
+	Chain           string          `json:"chain"`
+	Amount          decimal.Decimal `json:"amount"`
+	Address         string          `json:"address"`
+	AddressTag      string          `json:"addressTag"`
+	State           string          `json:"state"`
+	CreateTime      int64           `json:"createTime"`
+	UpdateTime      int64           `json:"updateTime"`
+}
\ No newline at end of file