ccxt-go/htx_api.go

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

// 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 *htx) V2PublicGetReferenceCurrencies (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 ("v2PublicGetReferenceCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PublicGetMarketStatus (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 ("v2PublicGetMarketStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountLedger (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 ("v2PrivateGetAccountLedger", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountWithdrawQuota (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 ("v2PrivateGetAccountWithdrawQuota", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountWithdrawAddress (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 ("v2PrivateGetAccountWithdrawAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountDepositAddress (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 ("v2PrivateGetAccountDepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountRepayment (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 ("v2PrivateGetAccountRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetReferenceTransactFeeRate (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 ("v2PrivateGetReferenceTransactFeeRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAccountAssetValuation (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 ("v2PrivateGetAccountAssetValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetPointAccount (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 ("v2PrivateGetPointAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetSubUserUserList (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 ("v2PrivateGetSubUserUserList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetSubUserUserState (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 ("v2PrivateGetSubUserUserState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetSubUserAccountList (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 ("v2PrivateGetSubUserAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetSubUserDepositAddress (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 ("v2PrivateGetSubUserDepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetSubUserQueryDeposit (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 ("v2PrivateGetSubUserQueryDeposit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetUserApiKey (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 ("v2PrivateGetUserApiKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetUserUid (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 ("v2PrivateGetUserUid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAlgoOrdersOpening (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 ("v2PrivateGetAlgoOrdersOpening", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAlgoOrdersHistory (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 ("v2PrivateGetAlgoOrdersHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetAlgoOrdersSpecific (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 ("v2PrivateGetAlgoOrdersSpecific", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetC2cOffers (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 ("v2PrivateGetC2cOffers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetC2cOffer (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 ("v2PrivateGetC2cOffer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetC2cTransactions (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 ("v2PrivateGetC2cTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetC2cRepayment (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 ("v2PrivateGetC2cRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetC2cAccount (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 ("v2PrivateGetC2cAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetEtpReference (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 ("v2PrivateGetEtpReference", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetEtpTransactions (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 ("v2PrivateGetEtpTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetEtpTransaction (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 ("v2PrivateGetEtpTransaction", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetEtpRebalance (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 ("v2PrivateGetEtpRebalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivateGetEtpLimit (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 ("v2PrivateGetEtpLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostAccountTransfer (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 ("v2PrivatePostAccountTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostAccountRepayment (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 ("v2PrivatePostAccountRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostPointTransfer (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 ("v2PrivatePostPointTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserManagement (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 ("v2PrivatePostSubUserManagement", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserCreation (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 ("v2PrivatePostSubUserCreation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserTradableMarket (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 ("v2PrivatePostSubUserTradableMarket", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserTransferability (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 ("v2PrivatePostSubUserTransferability", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserApiKeyGeneration (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 ("v2PrivatePostSubUserApiKeyGeneration", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserApiKeyModification (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 ("v2PrivatePostSubUserApiKeyModification", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserApiKeyDeletion (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 ("v2PrivatePostSubUserApiKeyDeletion", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostSubUserDeductMode (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 ("v2PrivatePostSubUserDeductMode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostAlgoOrders (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 ("v2PrivatePostAlgoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostAlgoOrdersCancelAllAfter (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 ("v2PrivatePostAlgoOrdersCancelAllAfter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostAlgoOrdersCancellation (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 ("v2PrivatePostAlgoOrdersCancellation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostC2cOffer (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 ("v2PrivatePostC2cOffer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostC2cCancellation (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 ("v2PrivatePostC2cCancellation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostC2cCancelAll (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 ("v2PrivatePostC2cCancelAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostC2cRepayment (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 ("v2PrivatePostC2cRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostC2cTransfer (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 ("v2PrivatePostC2cTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostEtpCreation (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 ("v2PrivatePostEtpCreation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostEtpRedemption (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 ("v2PrivatePostEtpRedemption", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostEtpTransactIdCancel (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 ("v2PrivatePostEtpTransactIdCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) V2PrivatePostEtpBatchCancel (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 ("v2PrivatePostEtpBatchCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PublicGetCommonSymbols (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 ("publicGetCommonSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PublicGetCommonCurrencys (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 ("publicGetCommonCurrencys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PublicGetCommonTimestamp (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 ("publicGetCommonTimestamp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PublicGetCommonExchange (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 ("publicGetCommonExchange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PublicGetSettingsCurrencys (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 ("publicGetSettingsCurrencys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetAccountAccounts (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 ("privateGetAccountAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetAccountAccountsIdBalance (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 ("privateGetAccountAccountsIdBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetAccountAccountsSubUid (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 ("privateGetAccountAccountsSubUid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetAccountHistory (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 ("privateGetAccountHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetCrossMarginLoanInfo (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 ("privateGetCrossMarginLoanInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetMarginLoanInfo (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 ("privateGetMarginLoanInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetFeeFeeRateGet (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 ("privateGetFeeFeeRateGet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderOpenOrders (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 ("privateGetOrderOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderOrders (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 ("privateGetOrderOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderOrdersId (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 ("privateGetOrderOrdersId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderOrdersIdMatchresults (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 ("privateGetOrderOrdersIdMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderOrdersGetClientOrder (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 ("privateGetOrderOrdersGetClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderHistory (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 ("privateGetOrderHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetOrderMatchresults (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 ("privateGetOrderMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetQueryDepositWithdraw (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 ("privateGetQueryDepositWithdraw", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetMarginLoanOrders (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 ("privateGetMarginLoanOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetMarginAccountsBalance (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 ("privateGetMarginAccountsBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetCrossMarginLoanOrders (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 ("privateGetCrossMarginLoanOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetCrossMarginAccountsBalance (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 ("privateGetCrossMarginAccountsBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetPointsActions (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 ("privateGetPointsActions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetPointsOrders (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 ("privateGetPointsOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetSubuserAggregateBalance (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 ("privateGetSubuserAggregateBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetStableCoinExchangeRate (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 ("privateGetStableCoinExchangeRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivateGetStableCoinQuote (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 ("privateGetStableCoinQuote", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostAccountTransfer (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 ("privatePostAccountTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostFuturesTransfer (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 ("privatePostFuturesTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderBatchOrders (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 ("privatePostOrderBatchOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderOrdersPlace (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 ("privatePostOrderOrdersPlace", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderOrdersSubmitCancelClientOrder (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 ("privatePostOrderOrdersSubmitCancelClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderOrdersBatchCancelOpenOrders (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 ("privatePostOrderOrdersBatchCancelOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderOrdersIdSubmitcancel (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 ("privatePostOrderOrdersIdSubmitcancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostOrderOrdersBatchcancel (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 ("privatePostOrderOrdersBatchcancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostDwWithdrawApiCreate (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 ("privatePostDwWithdrawApiCreate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostDwWithdrawVirtualIdCancel (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 ("privatePostDwWithdrawVirtualIdCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostDwTransferInMargin (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 ("privatePostDwTransferInMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostDwTransferOutMargin (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 ("privatePostDwTransferOutMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostMarginOrders (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 ("privatePostMarginOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostMarginOrdersIdRepay (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 ("privatePostMarginOrdersIdRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostCrossMarginTransferIn (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 ("privatePostCrossMarginTransferIn", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostCrossMarginTransferOut (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 ("privatePostCrossMarginTransferOut", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostCrossMarginOrders (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 ("privatePostCrossMarginOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostCrossMarginOrdersIdRepay (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 ("privatePostCrossMarginOrdersIdRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostStableCoinExchange (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 ("privatePostStableCoinExchange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) PrivatePostSubuserTransfer (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 ("privatePostSubuserTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) StatusPublicSpotGetApiV2SummaryJson (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 ("statusPublicSpotGetApiV2SummaryJson", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) StatusPublicFutureInverseGetApiV2SummaryJson (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 ("statusPublicFutureInverseGetApiV2SummaryJson", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) StatusPublicFutureLinearGetApiV2SummaryJson (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 ("statusPublicFutureLinearGetApiV2SummaryJson", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) StatusPublicSwapInverseGetApiV2SummaryJson (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 ("statusPublicSwapInverseGetApiV2SummaryJson", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) StatusPublicSwapLinearGetApiV2SummaryJson (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 ("statusPublicSwapLinearGetApiV2SummaryJson", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2MarketStatus (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 ("spotPublicGetV2MarketStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1CommonSymbols (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 ("spotPublicGetV1CommonSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1CommonCurrencys (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 ("spotPublicGetV1CommonCurrencys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2SettingsCommonCurrencies (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 ("spotPublicGetV2SettingsCommonCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2ReferenceCurrencies (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 ("spotPublicGetV2ReferenceCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1CommonTimestamp (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 ("spotPublicGetV1CommonTimestamp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1CommonExchange (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 ("spotPublicGetV1CommonExchange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1SettingsCommonChains (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 ("spotPublicGetV1SettingsCommonChains", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1SettingsCommonCurrencys (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 ("spotPublicGetV1SettingsCommonCurrencys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1SettingsCommonSymbols (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 ("spotPublicGetV1SettingsCommonSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2SettingsCommonSymbols (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 ("spotPublicGetV2SettingsCommonSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV1SettingsCommonMarketSymbols (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 ("spotPublicGetV1SettingsCommonMarketSymbols", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketHistoryCandles (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 ("spotPublicGetMarketHistoryCandles", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketHistoryKline (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 ("spotPublicGetMarketHistoryKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketDetailMerged (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 ("spotPublicGetMarketDetailMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketTickers (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 ("spotPublicGetMarketTickers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketDetail (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 ("spotPublicGetMarketDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketDepth (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 ("spotPublicGetMarketDepth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketTrade (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 ("spotPublicGetMarketTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketHistoryTrade (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 ("spotPublicGetMarketHistoryTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetMarketEtp (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 ("spotPublicGetMarketEtp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2EtpReference (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 ("spotPublicGetV2EtpReference", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPublicGetV2EtpRebalance (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 ("spotPublicGetV2EtpRebalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1AccountAccounts (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 ("spotPrivateGetV1AccountAccounts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1AccountAccountsAccountIdBalance (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 ("spotPrivateGetV1AccountAccountsAccountIdBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountValuation (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 ("spotPrivateGetV2AccountValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountAssetValuation (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 ("spotPrivateGetV2AccountAssetValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1AccountHistory (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 ("spotPrivateGetV1AccountHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountLedger (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 ("spotPrivateGetV2AccountLedger", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2PointAccount (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 ("spotPrivateGetV2PointAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountDepositAddress (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 ("spotPrivateGetV2AccountDepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountWithdrawQuota (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 ("spotPrivateGetV2AccountWithdrawQuota", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountWithdrawAddress (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 ("spotPrivateGetV2AccountWithdrawAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2ReferenceCurrencies (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 ("spotPrivateGetV2ReferenceCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1QueryDepositWithdraw (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 ("spotPrivateGetV1QueryDepositWithdraw", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1QueryWithdrawClientOrderId (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 ("spotPrivateGetV1QueryWithdrawClientOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2UserApiKey (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 ("spotPrivateGetV2UserApiKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2UserUid (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 ("spotPrivateGetV2UserUid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2SubUserUserList (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 ("spotPrivateGetV2SubUserUserList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2SubUserUserState (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 ("spotPrivateGetV2SubUserUserState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2SubUserAccountList (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 ("spotPrivateGetV2SubUserAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2SubUserDepositAddress (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 ("spotPrivateGetV2SubUserDepositAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2SubUserQueryDeposit (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 ("spotPrivateGetV2SubUserQueryDeposit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1SubuserAggregateBalance (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 ("spotPrivateGetV1SubuserAggregateBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1AccountAccountsSubUid (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 ("spotPrivateGetV1AccountAccountsSubUid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOpenOrders (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 ("spotPrivateGetV1OrderOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOrdersOrderId (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 ("spotPrivateGetV1OrderOrdersOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOrdersGetClientOrder (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 ("spotPrivateGetV1OrderOrdersGetClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOrdersOrderIdMatchresult (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 ("spotPrivateGetV1OrderOrdersOrderIdMatchresult", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOrdersOrderIdMatchresults (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 ("spotPrivateGetV1OrderOrdersOrderIdMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderOrders (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 ("spotPrivateGetV1OrderOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderHistory (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 ("spotPrivateGetV1OrderHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1OrderMatchresults (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 ("spotPrivateGetV1OrderMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2ReferenceTransactFeeRate (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 ("spotPrivateGetV2ReferenceTransactFeeRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AlgoOrdersOpening (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 ("spotPrivateGetV2AlgoOrdersOpening", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AlgoOrdersHistory (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 ("spotPrivateGetV2AlgoOrdersHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AlgoOrdersSpecific (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 ("spotPrivateGetV2AlgoOrdersSpecific", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1MarginLoanInfo (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 ("spotPrivateGetV1MarginLoanInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1MarginLoanOrders (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 ("spotPrivateGetV1MarginLoanOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1MarginAccountsBalance (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 ("spotPrivateGetV1MarginAccountsBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1CrossMarginLoanInfo (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 ("spotPrivateGetV1CrossMarginLoanInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1CrossMarginLoanOrders (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 ("spotPrivateGetV1CrossMarginLoanOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1CrossMarginAccountsBalance (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 ("spotPrivateGetV1CrossMarginAccountsBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2AccountRepayment (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 ("spotPrivateGetV2AccountRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1StableCoinQuote (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 ("spotPrivateGetV1StableCoinQuote", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV1StableCoinExchangeRate (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 ("spotPrivateGetV1StableCoinExchangeRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2EtpTransactions (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 ("spotPrivateGetV2EtpTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2EtpTransaction (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 ("spotPrivateGetV2EtpTransaction", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivateGetV2EtpLimit (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 ("spotPrivateGetV2EtpLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1AccountTransfer (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 ("spotPrivatePostV1AccountTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1FuturesTransfer (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 ("spotPrivatePostV1FuturesTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2PointTransfer (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 ("spotPrivatePostV2PointTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2AccountTransfer (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 ("spotPrivatePostV2AccountTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1DwWithdrawApiCreate (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 ("spotPrivatePostV1DwWithdrawApiCreate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1DwWithdrawVirtualWithdrawIdCancel (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 ("spotPrivatePostV1DwWithdrawVirtualWithdrawIdCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserDeductMode (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 ("spotPrivatePostV2SubUserDeductMode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserCreation (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 ("spotPrivatePostV2SubUserCreation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserManagement (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 ("spotPrivatePostV2SubUserManagement", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserTradableMarket (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 ("spotPrivatePostV2SubUserTradableMarket", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserTransferability (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 ("spotPrivatePostV2SubUserTransferability", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserApiKeyGeneration (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 ("spotPrivatePostV2SubUserApiKeyGeneration", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserApiKeyModification (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 ("spotPrivatePostV2SubUserApiKeyModification", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2SubUserApiKeyDeletion (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 ("spotPrivatePostV2SubUserApiKeyDeletion", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1SubuserTransfer (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 ("spotPrivatePostV1SubuserTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1TrustUserActiveCredit (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 ("spotPrivatePostV1TrustUserActiveCredit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderOrdersPlace (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 ("spotPrivatePostV1OrderOrdersPlace", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderBatchOrders (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 ("spotPrivatePostV1OrderBatchOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderAutoPlace (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 ("spotPrivatePostV1OrderAutoPlace", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderOrdersOrderIdSubmitcancel (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 ("spotPrivatePostV1OrderOrdersOrderIdSubmitcancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderOrdersSubmitCancelClientOrder (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 ("spotPrivatePostV1OrderOrdersSubmitCancelClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderOrdersBatchCancelOpenOrders (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 ("spotPrivatePostV1OrderOrdersBatchCancelOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1OrderOrdersBatchcancel (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 ("spotPrivatePostV1OrderOrdersBatchcancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2AlgoOrdersCancelAllAfter (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 ("spotPrivatePostV2AlgoOrdersCancelAllAfter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2AlgoOrders (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 ("spotPrivatePostV2AlgoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2AlgoOrdersCancellation (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 ("spotPrivatePostV2AlgoOrdersCancellation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2AccountRepayment (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 ("spotPrivatePostV2AccountRepayment", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1DwTransferInMargin (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 ("spotPrivatePostV1DwTransferInMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1DwTransferOutMargin (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 ("spotPrivatePostV1DwTransferOutMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1MarginOrders (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 ("spotPrivatePostV1MarginOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1MarginOrdersOrderIdRepay (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 ("spotPrivatePostV1MarginOrdersOrderIdRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1CrossMarginTransferIn (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 ("spotPrivatePostV1CrossMarginTransferIn", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1CrossMarginTransferOut (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 ("spotPrivatePostV1CrossMarginTransferOut", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1CrossMarginOrders (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 ("spotPrivatePostV1CrossMarginOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1CrossMarginOrdersOrderIdRepay (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 ("spotPrivatePostV1CrossMarginOrdersOrderIdRepay", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV1StableCoinExchange (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 ("spotPrivatePostV1StableCoinExchange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2EtpCreation (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 ("spotPrivatePostV2EtpCreation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2EtpRedemption (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 ("spotPrivatePostV2EtpRedemption", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2EtpTransactIdCancel (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 ("spotPrivatePostV2EtpTransactIdCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) SpotPrivatePostV2EtpBatchCancel (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 ("spotPrivatePostV2EtpBatchCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1Timestamp (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 ("contractPublicGetApiV1Timestamp", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetHeartbeat (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 ("contractPublicGetHeartbeat", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractContractInfo (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 ("contractPublicGetApiV1ContractContractInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractIndex (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 ("contractPublicGetApiV1ContractIndex", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractQueryElements (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 ("contractPublicGetApiV1ContractQueryElements", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractPriceLimit (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 ("contractPublicGetApiV1ContractPriceLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractOpenInterest (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 ("contractPublicGetApiV1ContractOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractDeliveryPrice (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 ("contractPublicGetApiV1ContractDeliveryPrice", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketDepth (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 ("contractPublicGetMarketDepth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketBbo (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 ("contractPublicGetMarketBbo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketHistoryKline (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 ("contractPublicGetMarketHistoryKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryMarkPriceKline (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 ("contractPublicGetIndexMarketHistoryMarkPriceKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketDetailMerged (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 ("contractPublicGetMarketDetailMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketDetailBatchMerged (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 ("contractPublicGetMarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetV2MarketDetailBatchMerged (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 ("contractPublicGetV2MarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketTrade (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 ("contractPublicGetMarketTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetMarketHistoryTrade (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 ("contractPublicGetMarketHistoryTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractRiskInfo (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 ("contractPublicGetApiV1ContractRiskInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractInsuranceFund (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 ("contractPublicGetApiV1ContractInsuranceFund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractAdjustfactor (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 ("contractPublicGetApiV1ContractAdjustfactor", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractHisOpenInterest (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 ("contractPublicGetApiV1ContractHisOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractLadderMargin (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 ("contractPublicGetApiV1ContractLadderMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractApiState (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 ("contractPublicGetApiV1ContractApiState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractEliteAccountRatio (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 ("contractPublicGetApiV1ContractEliteAccountRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractElitePositionRatio (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 ("contractPublicGetApiV1ContractElitePositionRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractLiquidationOrders (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 ("contractPublicGetApiV1ContractLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractSettlementRecords (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 ("contractPublicGetApiV1ContractSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryIndex (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 ("contractPublicGetIndexMarketHistoryIndex", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryBasis (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 ("contractPublicGetIndexMarketHistoryBasis", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV1ContractEstimatedSettlementPrice (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 ("contractPublicGetApiV1ContractEstimatedSettlementPrice", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetApiV3ContractLiquidationOrders (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 ("contractPublicGetApiV3ContractLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapContractInfo (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 ("contractPublicGetSwapApiV1SwapContractInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapIndex (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 ("contractPublicGetSwapApiV1SwapIndex", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapQueryElements (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 ("contractPublicGetSwapApiV1SwapQueryElements", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapPriceLimit (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 ("contractPublicGetSwapApiV1SwapPriceLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapOpenInterest (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 ("contractPublicGetSwapApiV1SwapOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketDepth (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 ("contractPublicGetSwapExMarketDepth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketBbo (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 ("contractPublicGetSwapExMarketBbo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketHistoryKline (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 ("contractPublicGetSwapExMarketHistoryKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistorySwapMarkPriceKline (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 ("contractPublicGetIndexMarketHistorySwapMarkPriceKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketDetailMerged (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 ("contractPublicGetSwapExMarketDetailMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetV2SwapExMarketDetailBatchMerged (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 ("contractPublicGetV2SwapExMarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistorySwapPremiumIndexKline (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 ("contractPublicGetIndexMarketHistorySwapPremiumIndexKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketDetailBatchMerged (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 ("contractPublicGetSwapExMarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketTrade (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 ("contractPublicGetSwapExMarketTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapExMarketHistoryTrade (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 ("contractPublicGetSwapExMarketHistoryTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapRiskInfo (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 ("contractPublicGetSwapApiV1SwapRiskInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapInsuranceFund (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 ("contractPublicGetSwapApiV1SwapInsuranceFund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapAdjustfactor (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 ("contractPublicGetSwapApiV1SwapAdjustfactor", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapHisOpenInterest (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 ("contractPublicGetSwapApiV1SwapHisOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapLadderMargin (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 ("contractPublicGetSwapApiV1SwapLadderMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapApiState (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 ("contractPublicGetSwapApiV1SwapApiState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapEliteAccountRatio (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 ("contractPublicGetSwapApiV1SwapEliteAccountRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapElitePositionRatio (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 ("contractPublicGetSwapApiV1SwapElitePositionRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapEstimatedSettlementPrice (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 ("contractPublicGetSwapApiV1SwapEstimatedSettlementPrice", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapLiquidationOrders (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 ("contractPublicGetSwapApiV1SwapLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapSettlementRecords (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 ("contractPublicGetSwapApiV1SwapSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapFundingRate (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 ("contractPublicGetSwapApiV1SwapFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapBatchFundingRate (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 ("contractPublicGetSwapApiV1SwapBatchFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1SwapHistoricalFundingRate (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 ("contractPublicGetSwapApiV1SwapHistoricalFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV3SwapLiquidationOrders (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 ("contractPublicGetSwapApiV3SwapLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistorySwapEstimatedRateKline (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 ("contractPublicGetIndexMarketHistorySwapEstimatedRateKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistorySwapBasis (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 ("contractPublicGetIndexMarketHistorySwapBasis", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapContractInfo (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 ("contractPublicGetLinearSwapApiV1SwapContractInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapIndex (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 ("contractPublicGetLinearSwapApiV1SwapIndex", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapQueryElements (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 ("contractPublicGetLinearSwapApiV1SwapQueryElements", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapPriceLimit (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 ("contractPublicGetLinearSwapApiV1SwapPriceLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapOpenInterest (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 ("contractPublicGetLinearSwapApiV1SwapOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketDepth (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 ("contractPublicGetLinearSwapExMarketDepth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketBbo (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 ("contractPublicGetLinearSwapExMarketBbo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketHistoryKline (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 ("contractPublicGetLinearSwapExMarketHistoryKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryLinearSwapMarkPriceKline (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 ("contractPublicGetIndexMarketHistoryLinearSwapMarkPriceKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketDetailMerged (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 ("contractPublicGetLinearSwapExMarketDetailMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketDetailBatchMerged (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 ("contractPublicGetLinearSwapExMarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetV2LinearSwapExMarketDetailBatchMerged (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 ("contractPublicGetV2LinearSwapExMarketDetailBatchMerged", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketTrade (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 ("contractPublicGetLinearSwapExMarketTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapExMarketHistoryTrade (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 ("contractPublicGetLinearSwapExMarketHistoryTrade", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapRiskInfo (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 ("contractPublicGetLinearSwapApiV1SwapRiskInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetSwapApiV1LinearSwapApiV1SwapInsuranceFund (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 ("contractPublicGetSwapApiV1LinearSwapApiV1SwapInsuranceFund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapAdjustfactor (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 ("contractPublicGetLinearSwapApiV1SwapAdjustfactor", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapCrossAdjustfactor (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 ("contractPublicGetLinearSwapApiV1SwapCrossAdjustfactor", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapHisOpenInterest (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 ("contractPublicGetLinearSwapApiV1SwapHisOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapLadderMargin (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 ("contractPublicGetLinearSwapApiV1SwapLadderMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapCrossLadderMargin (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 ("contractPublicGetLinearSwapApiV1SwapCrossLadderMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapApiState (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 ("contractPublicGetLinearSwapApiV1SwapApiState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapCrossTransferState (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 ("contractPublicGetLinearSwapApiV1SwapCrossTransferState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapCrossTradeState (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 ("contractPublicGetLinearSwapApiV1SwapCrossTradeState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapEliteAccountRatio (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 ("contractPublicGetLinearSwapApiV1SwapEliteAccountRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapElitePositionRatio (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 ("contractPublicGetLinearSwapApiV1SwapElitePositionRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapLiquidationOrders (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 ("contractPublicGetLinearSwapApiV1SwapLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapSettlementRecords (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 ("contractPublicGetLinearSwapApiV1SwapSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapFundingRate (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 ("contractPublicGetLinearSwapApiV1SwapFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapBatchFundingRate (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 ("contractPublicGetLinearSwapApiV1SwapBatchFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapHistoricalFundingRate (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 ("contractPublicGetLinearSwapApiV1SwapHistoricalFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV3SwapLiquidationOrders (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 ("contractPublicGetLinearSwapApiV3SwapLiquidationOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryLinearSwapPremiumIndexKline (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 ("contractPublicGetIndexMarketHistoryLinearSwapPremiumIndexKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryLinearSwapEstimatedRateKline (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 ("contractPublicGetIndexMarketHistoryLinearSwapEstimatedRateKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetIndexMarketHistoryLinearSwapBasis (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 ("contractPublicGetIndexMarketHistoryLinearSwapBasis", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPublicGetLinearSwapApiV1SwapEstimatedSettlementPrice (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 ("contractPublicGetLinearSwapApiV1SwapEstimatedSettlementPrice", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetApiV1ContractSubAuthList (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 ("contractPrivateGetApiV1ContractSubAuthList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetApiV1ContractApiTradingStatus (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 ("contractPrivateGetApiV1ContractApiTradingStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetSwapApiV1SwapSubAuthList (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 ("contractPrivateGetSwapApiV1SwapSubAuthList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetSwapApiV1SwapApiTradingStatus (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 ("contractPrivateGetSwapApiV1SwapApiTradingStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV1SwapSubAuthList (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 ("contractPrivateGetLinearSwapApiV1SwapSubAuthList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV1SwapApiTradingStatus (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 ("contractPrivateGetLinearSwapApiV1SwapApiTradingStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV1SwapCrossPositionSide (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 ("contractPrivateGetLinearSwapApiV1SwapCrossPositionSide", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV1SwapPositionSide (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 ("contractPrivateGetLinearSwapApiV1SwapPositionSide", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV3UnifiedAccountInfo (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 ("contractPrivateGetLinearSwapApiV3UnifiedAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV3FixPositionMarginChangeRecord (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 ("contractPrivateGetLinearSwapApiV3FixPositionMarginChangeRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV3SwapUnifiedAccountType (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 ("contractPrivateGetLinearSwapApiV3SwapUnifiedAccountType", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivateGetLinearSwapApiV3LinearSwapOverviewAccountInfo (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 ("contractPrivateGetLinearSwapApiV3LinearSwapOverviewAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractBalanceValuation (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 ("contractPrivatePostApiV1ContractBalanceValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractAccountInfo (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 ("contractPrivatePostApiV1ContractAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractPositionInfo (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 ("contractPrivatePostApiV1ContractPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSubAuth (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 ("contractPrivatePostApiV1ContractSubAuth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSubAccountList (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 ("contractPrivatePostApiV1ContractSubAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSubAccountInfoList (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 ("contractPrivatePostApiV1ContractSubAccountInfoList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSubAccountInfo (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 ("contractPrivatePostApiV1ContractSubAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSubPositionInfo (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 ("contractPrivatePostApiV1ContractSubPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractFinancialRecord (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 ("contractPrivatePostApiV1ContractFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractFinancialRecordExact (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 ("contractPrivatePostApiV1ContractFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractUserSettlementRecords (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 ("contractPrivatePostApiV1ContractUserSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractOrderLimit (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 ("contractPrivatePostApiV1ContractOrderLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractFee (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 ("contractPrivatePostApiV1ContractFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTransferLimit (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 ("contractPrivatePostApiV1ContractTransferLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractPositionLimit (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 ("contractPrivatePostApiV1ContractPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractAccountPositionInfo (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 ("contractPrivatePostApiV1ContractAccountPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractMasterSubTransfer (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 ("contractPrivatePostApiV1ContractMasterSubTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractMasterSubTransferRecord (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 ("contractPrivatePostApiV1ContractMasterSubTransferRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractAvailableLevelRate (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 ("contractPrivatePostApiV1ContractAvailableLevelRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractFinancialRecord (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 ("contractPrivatePostApiV3ContractFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractFinancialRecordExact (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 ("contractPrivatePostApiV3ContractFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractCancelAfter (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 ("contractPrivatePostApiV1ContractCancelAfter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractOrder (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 ("contractPrivatePostApiV1ContractOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractBatchorder (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 ("contractPrivatePostApiV1ContractBatchorder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractCancel (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 ("contractPrivatePostApiV1ContractCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractCancelall (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 ("contractPrivatePostApiV1ContractCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractSwitchLeverRate (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 ("contractPrivatePostApiV1ContractSwitchLeverRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1LightningClosePosition (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 ("contractPrivatePostApiV1LightningClosePosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractOrderInfo (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 ("contractPrivatePostApiV1ContractOrderInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractOrderDetail (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 ("contractPrivatePostApiV1ContractOrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractOpenorders (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 ("contractPrivatePostApiV1ContractOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractHisorders (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 ("contractPrivatePostApiV1ContractHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractHisordersExact (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 ("contractPrivatePostApiV1ContractHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractMatchresults (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 ("contractPrivatePostApiV1ContractMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractMatchresultsExact (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 ("contractPrivatePostApiV1ContractMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractHisorders (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 ("contractPrivatePostApiV3ContractHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractHisordersExact (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 ("contractPrivatePostApiV3ContractHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractMatchresults (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 ("contractPrivatePostApiV3ContractMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV3ContractMatchresultsExact (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 ("contractPrivatePostApiV3ContractMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTriggerOrder (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 ("contractPrivatePostApiV1ContractTriggerOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTriggerCancel (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 ("contractPrivatePostApiV1ContractTriggerCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTriggerCancelall (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 ("contractPrivatePostApiV1ContractTriggerCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTriggerOpenorders (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 ("contractPrivatePostApiV1ContractTriggerOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTriggerHisorders (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 ("contractPrivatePostApiV1ContractTriggerHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTpslOrder (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 ("contractPrivatePostApiV1ContractTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTpslCancel (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 ("contractPrivatePostApiV1ContractTpslCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTpslCancelall (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 ("contractPrivatePostApiV1ContractTpslCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTpslOpenorders (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 ("contractPrivatePostApiV1ContractTpslOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTpslHisorders (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 ("contractPrivatePostApiV1ContractTpslHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractRelationTpslOrder (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 ("contractPrivatePostApiV1ContractRelationTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTrackOrder (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 ("contractPrivatePostApiV1ContractTrackOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTrackCancel (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 ("contractPrivatePostApiV1ContractTrackCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTrackCancelall (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 ("contractPrivatePostApiV1ContractTrackCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTrackOpenorders (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 ("contractPrivatePostApiV1ContractTrackOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostApiV1ContractTrackHisorders (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 ("contractPrivatePostApiV1ContractTrackHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapBalanceValuation (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 ("contractPrivatePostSwapApiV1SwapBalanceValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapAccountInfo (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 ("contractPrivatePostSwapApiV1SwapAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapPositionInfo (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 ("contractPrivatePostSwapApiV1SwapPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapAccountPositionInfo (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 ("contractPrivatePostSwapApiV1SwapAccountPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSubAuth (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 ("contractPrivatePostSwapApiV1SwapSubAuth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSubAccountList (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 ("contractPrivatePostSwapApiV1SwapSubAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSubAccountInfoList (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 ("contractPrivatePostSwapApiV1SwapSubAccountInfoList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSubAccountInfo (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 ("contractPrivatePostSwapApiV1SwapSubAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSubPositionInfo (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 ("contractPrivatePostSwapApiV1SwapSubPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapFinancialRecord (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 ("contractPrivatePostSwapApiV1SwapFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapFinancialRecordExact (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 ("contractPrivatePostSwapApiV1SwapFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapUserSettlementRecords (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 ("contractPrivatePostSwapApiV1SwapUserSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapAvailableLevelRate (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 ("contractPrivatePostSwapApiV1SwapAvailableLevelRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapOrderLimit (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 ("contractPrivatePostSwapApiV1SwapOrderLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapFee (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 ("contractPrivatePostSwapApiV1SwapFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTransferLimit (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 ("contractPrivatePostSwapApiV1SwapTransferLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapPositionLimit (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 ("contractPrivatePostSwapApiV1SwapPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapMasterSubTransfer (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 ("contractPrivatePostSwapApiV1SwapMasterSubTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapMasterSubTransferRecord (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 ("contractPrivatePostSwapApiV1SwapMasterSubTransferRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapFinancialRecord (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 ("contractPrivatePostSwapApiV3SwapFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapFinancialRecordExact (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 ("contractPrivatePostSwapApiV3SwapFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapCancelAfter (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 ("contractPrivatePostSwapApiV1SwapCancelAfter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapOrder (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 ("contractPrivatePostSwapApiV1SwapOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapBatchorder (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 ("contractPrivatePostSwapApiV1SwapBatchorder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapCancel (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 ("contractPrivatePostSwapApiV1SwapCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapCancelall (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 ("contractPrivatePostSwapApiV1SwapCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapLightningClosePosition (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 ("contractPrivatePostSwapApiV1SwapLightningClosePosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapSwitchLeverRate (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 ("contractPrivatePostSwapApiV1SwapSwitchLeverRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapOrderInfo (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 ("contractPrivatePostSwapApiV1SwapOrderInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapOrderDetail (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 ("contractPrivatePostSwapApiV1SwapOrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapOpenorders (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 ("contractPrivatePostSwapApiV1SwapOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapHisorders (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 ("contractPrivatePostSwapApiV1SwapHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapHisordersExact (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 ("contractPrivatePostSwapApiV1SwapHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapMatchresults (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 ("contractPrivatePostSwapApiV1SwapMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapMatchresultsExact (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 ("contractPrivatePostSwapApiV1SwapMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapMatchresults (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 ("contractPrivatePostSwapApiV3SwapMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapMatchresultsExact (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 ("contractPrivatePostSwapApiV3SwapMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapHisorders (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 ("contractPrivatePostSwapApiV3SwapHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV3SwapHisordersExact (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 ("contractPrivatePostSwapApiV3SwapHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTriggerOrder (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 ("contractPrivatePostSwapApiV1SwapTriggerOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTriggerCancel (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 ("contractPrivatePostSwapApiV1SwapTriggerCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTriggerCancelall (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 ("contractPrivatePostSwapApiV1SwapTriggerCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTriggerOpenorders (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 ("contractPrivatePostSwapApiV1SwapTriggerOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTriggerHisorders (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 ("contractPrivatePostSwapApiV1SwapTriggerHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTpslOrder (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 ("contractPrivatePostSwapApiV1SwapTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTpslCancel (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 ("contractPrivatePostSwapApiV1SwapTpslCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTpslCancelall (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 ("contractPrivatePostSwapApiV1SwapTpslCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTpslOpenorders (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 ("contractPrivatePostSwapApiV1SwapTpslOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTpslHisorders (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 ("contractPrivatePostSwapApiV1SwapTpslHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapRelationTpslOrder (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 ("contractPrivatePostSwapApiV1SwapRelationTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTrackOrder (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 ("contractPrivatePostSwapApiV1SwapTrackOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTrackCancel (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 ("contractPrivatePostSwapApiV1SwapTrackCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTrackCancelall (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 ("contractPrivatePostSwapApiV1SwapTrackCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTrackOpenorders (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 ("contractPrivatePostSwapApiV1SwapTrackOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostSwapApiV1SwapTrackHisorders (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 ("contractPrivatePostSwapApiV1SwapTrackHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapLeverPositionLimit (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 ("contractPrivatePostLinearSwapApiV1SwapLeverPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossLeverPositionLimit (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 ("contractPrivatePostLinearSwapApiV1SwapCrossLeverPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapBalanceValuation (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 ("contractPrivatePostLinearSwapApiV1SwapBalanceValuation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapAccountInfo (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 ("contractPrivatePostLinearSwapApiV1SwapAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossAccountInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapAccountPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapAccountPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossAccountPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossAccountPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSubAuth (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 ("contractPrivatePostLinearSwapApiV1SwapSubAuth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSubAccountList (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 ("contractPrivatePostLinearSwapApiV1SwapSubAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSubAccountList (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSubAccountList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSubAccountInfoList (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 ("contractPrivatePostLinearSwapApiV1SwapSubAccountInfoList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSubAccountInfoList (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSubAccountInfoList", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSubAccountInfo (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 ("contractPrivatePostLinearSwapApiV1SwapSubAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSubAccountInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSubAccountInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSubPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapSubPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSubPositionInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSubPositionInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapFinancialRecord (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 ("contractPrivatePostLinearSwapApiV1SwapFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapFinancialRecordExact (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 ("contractPrivatePostLinearSwapApiV1SwapFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapUserSettlementRecords (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 ("contractPrivatePostLinearSwapApiV1SwapUserSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossUserSettlementRecords (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 ("contractPrivatePostLinearSwapApiV1SwapCrossUserSettlementRecords", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapAvailableLevelRate (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 ("contractPrivatePostLinearSwapApiV1SwapAvailableLevelRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossAvailableLevelRate (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 ("contractPrivatePostLinearSwapApiV1SwapCrossAvailableLevelRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapOrderLimit (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 ("contractPrivatePostLinearSwapApiV1SwapOrderLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapFee (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 ("contractPrivatePostLinearSwapApiV1SwapFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTransferLimit (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 ("contractPrivatePostLinearSwapApiV1SwapTransferLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTransferLimit (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTransferLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapPositionLimit (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 ("contractPrivatePostLinearSwapApiV1SwapPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossPositionLimit (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 ("contractPrivatePostLinearSwapApiV1SwapCrossPositionLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapMasterSubTransfer (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 ("contractPrivatePostLinearSwapApiV1SwapMasterSubTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapMasterSubTransferRecord (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 ("contractPrivatePostLinearSwapApiV1SwapMasterSubTransferRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTransferInner (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 ("contractPrivatePostLinearSwapApiV1SwapTransferInner", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapFinancialRecord (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 ("contractPrivatePostLinearSwapApiV3SwapFinancialRecord", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapFinancialRecordExact (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 ("contractPrivatePostLinearSwapApiV3SwapFinancialRecordExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapOrder (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 ("contractPrivatePostLinearSwapApiV1SwapOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossOrder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapBatchorder (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 ("contractPrivatePostLinearSwapApiV1SwapBatchorder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossBatchorder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossBatchorder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCancel (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 ("contractPrivatePostLinearSwapApiV1SwapCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossCancel (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 ("contractPrivatePostLinearSwapApiV1SwapCrossCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapCrossCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSwitchLeverRate (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 ("contractPrivatePostLinearSwapApiV1SwapSwitchLeverRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSwitchLeverRate (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSwitchLeverRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapLightningClosePosition (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 ("contractPrivatePostLinearSwapApiV1SwapLightningClosePosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossLightningClosePosition (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 ("contractPrivatePostLinearSwapApiV1SwapCrossLightningClosePosition", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapOrderInfo (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 ("contractPrivatePostLinearSwapApiV1SwapOrderInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossOrderInfo (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 ("contractPrivatePostLinearSwapApiV1SwapCrossOrderInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapOrderDetail (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 ("contractPrivatePostLinearSwapApiV1SwapOrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossOrderDetail (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 ("contractPrivatePostLinearSwapApiV1SwapCrossOrderDetail", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapHisordersExact (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 ("contractPrivatePostLinearSwapApiV1SwapHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossHisordersExact (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 ("contractPrivatePostLinearSwapApiV1SwapCrossHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapMatchresults (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 ("contractPrivatePostLinearSwapApiV1SwapMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossMatchresults (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 ("contractPrivatePostLinearSwapApiV1SwapCrossMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapMatchresultsExact (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 ("contractPrivatePostLinearSwapApiV1SwapMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossMatchresultsExact (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 ("contractPrivatePostLinearSwapApiV1SwapCrossMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1LinearCancelAfter (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 ("contractPrivatePostLinearSwapApiV1LinearCancelAfter", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapSwitchPositionMode (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 ("contractPrivatePostLinearSwapApiV1SwapSwitchPositionMode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossSwitchPositionMode (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 ("contractPrivatePostLinearSwapApiV1SwapCrossSwitchPositionMode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapMatchresults (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 ("contractPrivatePostLinearSwapApiV3SwapMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapCrossMatchresults (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 ("contractPrivatePostLinearSwapApiV3SwapCrossMatchresults", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapMatchresultsExact (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 ("contractPrivatePostLinearSwapApiV3SwapMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapCrossMatchresultsExact (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 ("contractPrivatePostLinearSwapApiV3SwapCrossMatchresultsExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapHisorders (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 ("contractPrivatePostLinearSwapApiV3SwapHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapCrossHisorders (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 ("contractPrivatePostLinearSwapApiV3SwapCrossHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapHisordersExact (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 ("contractPrivatePostLinearSwapApiV3SwapHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapCrossHisordersExact (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 ("contractPrivatePostLinearSwapApiV3SwapCrossHisordersExact", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3FixPositionMarginChange (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 ("contractPrivatePostLinearSwapApiV3FixPositionMarginChange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3SwapSwitchAccountType (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 ("contractPrivatePostLinearSwapApiV3SwapSwitchAccountType", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV3LinearSwapFeeSwitch (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 ("contractPrivatePostLinearSwapApiV3LinearSwapFeeSwitch", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTriggerOrder (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 ("contractPrivatePostLinearSwapApiV1SwapTriggerOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTriggerOrder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTriggerOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTriggerCancel (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 ("contractPrivatePostLinearSwapApiV1SwapTriggerCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTriggerCancel (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTriggerCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTriggerCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapTriggerCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTriggerCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTriggerCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTriggerOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapTriggerOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTriggerOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTriggerOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTriggerHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapTriggerHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTriggerHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTriggerHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTpslOrder (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 ("contractPrivatePostLinearSwapApiV1SwapTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTpslOrder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTpslCancel (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 ("contractPrivatePostLinearSwapApiV1SwapTpslCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTpslCancel (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTpslCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTpslCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapTpslCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTpslCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTpslCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTpslOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapTpslOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTpslOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTpslOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTpslHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapTpslHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTpslHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTpslHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapRelationTpslOrder (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 ("contractPrivatePostLinearSwapApiV1SwapRelationTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossRelationTpslOrder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossRelationTpslOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTrackOrder (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 ("contractPrivatePostLinearSwapApiV1SwapTrackOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTrackOrder (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTrackOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTrackCancel (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 ("contractPrivatePostLinearSwapApiV1SwapTrackCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTrackCancel (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTrackCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTrackCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapTrackCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTrackCancelall (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTrackCancelall", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTrackOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapTrackOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTrackOpenorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTrackOpenorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapTrackHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapTrackHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *htx) ContractPrivatePostLinearSwapApiV1SwapCrossTrackHisorders (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 ("contractPrivatePostLinearSwapApiV1SwapCrossTrackHisorders", parameters))
       PanicOnError(ch)
   }()
   return ch
}