// -------------------------------------------------------------------------------

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

// -------------------------------------------------------------------------------

package ccxt

func (this *bitmart) PublicGetSystemTime (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSystemTime", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSystemService (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSystemService", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1Currencies (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1Currencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1Symbols (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1Symbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1SymbolsDetails (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1SymbolsDetails", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3Tickers (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3Tickers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3Ticker (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3Ticker", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3LiteKlines (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3LiteKlines", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3Klines (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3Klines", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3Books (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3Books", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotQuotationV3Trades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotQuotationV3Trades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1Ticker (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1Ticker", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV2Ticker (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV2Ticker", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1TickerDetail (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1TickerDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1Steps (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1Steps", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1SymbolsKline (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1SymbolsKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1SymbolsBook (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1SymbolsBook", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetSpotV1SymbolsTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetSpotV1SymbolsTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractV1Tickers (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractV1Tickers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicDetails (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicDetails", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicDepth (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicDepth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicOpenInterest (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicFundingRate (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicFundingRateHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicFundingRateHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicKline (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetAccountV1Currencies (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetAccountV1Currencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PublicGetContractPublicMarkpriceKline (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetContractPublicMarkpriceKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountSubAccountV1TransferList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountSubAccountV1TransferList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountSubAccountV1TransferHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountSubAccountV1TransferHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountSubAccountMainV1Wallet (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountSubAccountMainV1Wallet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountSubAccountMainV1SubaccountList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountSubAccountMainV1SubaccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountContractSubAccountMainV1Wallet (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountContractSubAccountMainV1Wallet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountContractSubAccountMainV1TransferList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountContractSubAccountMainV1TransferList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountContractSubAccountV1TransferHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountContractSubAccountV1TransferHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1Wallet (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1Wallet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1Currencies (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1Currencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1Wallet (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1Wallet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1DepositAddress (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1DepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1WithdrawCharge (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1WithdrawCharge", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV2DepositWithdrawHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV2DepositWithdrawHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1DepositWithdrawDetail (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1DepositWithdrawDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetAccountV1WithdrawAddressList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetAccountV1WithdrawAddressList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1OrderDetail (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1OrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV2Orders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV2Orders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1Trades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1Trades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV2Trades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV2Trades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV3Orders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV3Orders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV2OrderDetail (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV2OrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1MarginIsolatedBorrowRecord (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1MarginIsolatedBorrowRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1MarginIsolatedRepayRecord (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1MarginIsolatedRepayRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1MarginIsolatedPairs (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1MarginIsolatedPairs", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1MarginIsolatedAccount (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1MarginIsolatedAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1TradeFee (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1TradeFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1UserFee (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1UserFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetSpotV1BrokerRebate (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetSpotV1BrokerRebate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateAssetsDetail (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateAssetsDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateOrderHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateOrderHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivatePosition (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivatePosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateGetOpenOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateGetOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateCurrentPlanOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateCurrentPlanOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivatePositionRisk (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivatePositionRisk", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateAffilateRebateList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateAffilateRebateList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateAffilateTradeList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateAffilateTradeList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivateGetContractPrivateTransactionHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privateGetContractPrivateTransactionHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountSubAccountMainV1SubToMain (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountSubAccountMainV1SubToMain", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountSubAccountSubV1SubToMain (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountSubAccountSubV1SubToMain", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountSubAccountMainV1MainToSub (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountSubAccountMainV1MainToSub", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountSubAccountSubV1SubToSub (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountSubAccountSubV1SubToSub", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountSubAccountMainV1SubToSub (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountSubAccountMainV1SubToSub", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountContractSubAccountMainV1SubToMain (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountContractSubAccountMainV1SubToMain", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountContractSubAccountMainV1MainToSub (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountContractSubAccountMainV1MainToSub", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountContractSubAccountSubV1SubToMain (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountContractSubAccountSubV1SubToMain", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountV1WithdrawApply (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountV1WithdrawApply", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1SubmitOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1SubmitOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1BatchOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1BatchOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV2CancelOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV2CancelOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1CancelOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1CancelOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryClientOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryOpenOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryHistoryOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryHistoryOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4QueryOrderTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4QueryOrderTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4CancelOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4CancelOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4CancelAll (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4CancelAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV4BatchOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV4BatchOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV3CancelOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV3CancelOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV2BatchOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV2BatchOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV2SubmitOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV2SubmitOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1MarginSubmitOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1MarginSubmitOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1MarginIsolatedBorrow (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1MarginIsolatedBorrow", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1MarginIsolatedRepay (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1MarginIsolatedRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostSpotV1MarginIsolatedTransfer (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSpotV1MarginIsolatedTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountV1TransferContractList (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountV1TransferContractList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostAccountV1TransferContract (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAccountV1TransferContract", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateSubmitOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateSubmitOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateCancelOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateCancelOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateCancelOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateCancelOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateSubmitPlanOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateSubmitPlanOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateCancelPlanOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateCancelPlanOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateSubmitLeverage (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateSubmitLeverage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateSubmitTpSlOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateSubmitTpSlOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateModifyPlanOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateModifyPlanOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateModifyPresetPlanOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateModifyPresetPlanOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateModifyTpSlOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateModifyTpSlOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateSubmitTrailOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateSubmitTrailOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *bitmart) PrivatePostContractPrivateCancelTrailOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostContractPrivateCancelTrailOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}