2409 lines
71 KiB
Go
2409 lines
71 KiB
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 *xt) PublicSpotGetCurrencies (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetCurrencies", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetDepth (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetDepth", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetKline (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetKline", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetSymbol (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetSymbol", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTicker (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTicker", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTickerBook (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTickerBook", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTickerPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTickerPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTicker24h (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTicker24h", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTime (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTime", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTradeHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTradeHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetTradeRecent (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetTradeRecent", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicSpotGetWalletSupportCurrency (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicSpotGetWalletSupportCurrency", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicContractRiskBalance (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicContractRiskBalance", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicContractOpenInterest (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicContractOpenInterest", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicLeverageBracketDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicLeverageBracketDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicLeverageBracketList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicLeverageBracketList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQAggTicker (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQAggTicker", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQAggTickers (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQAggTickers", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQDeal (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQDeal", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQDepth (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQDepth", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQFundingRate (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQFundingRate", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQFundingRateRecord (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQFundingRateRecord", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQIndexPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQIndexPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQKline (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQKline", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQMarkPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQMarkPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQSymbolIndexPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQSymbolIndexPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQSymbolMarkPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQSymbolMarkPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQTicker (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQTicker", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicQTickers (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicQTickers", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicSymbolCoins (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicSymbolCoins", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicSymbolDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicSymbolDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicLinearGetFutureMarketV1PublicSymbolList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicLinearGetFutureMarketV1PublicSymbolList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicContractRiskBalance (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicContractRiskBalance", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicContractOpenInterest (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicContractOpenInterest", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicLeverageBracketDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicLeverageBracketDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicLeverageBracketList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicLeverageBracketList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQAggTicker (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQAggTicker", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQAggTickers (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQAggTickers", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQDeal (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQDeal", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQDepth (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQDepth", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQFundingRate (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQFundingRate", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQFundingRateRecord (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQFundingRateRecord", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQIndexPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQIndexPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQKline (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQKline", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQMarkPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQMarkPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQSymbolIndexPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQSymbolIndexPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQSymbolMarkPrice (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQSymbolMarkPrice", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQTicker (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQTicker", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicQTickers (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicQTickers", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicSymbolCoins (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicSymbolCoins", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicSymbolDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicSymbolDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PublicInverseGetFutureMarketV1PublicSymbolList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("publicInverseGetFutureMarketV1PublicSymbolList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetBalance (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetBalance", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetBalances (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetBalances", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetBatchOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetBatchOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetDepositAddress (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetDepositAddress", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetDepositHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetDepositHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetHistoryOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetHistoryOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetOpenOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetOpenOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetOrderOrderId (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetOrderOrderId", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetTrade (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetTrade", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotGetWithdrawHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotGetWithdrawHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotPostOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotPostOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotPostWithdraw (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotPostWithdraw", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotPostBalanceTransfer (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotPostBalanceTransfer", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotPostBalanceAccountTransfer (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotPostBalanceAccountTransfer", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotPostWsToken (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotPostWsToken", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotDeleteBatchOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotDeleteBatchOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotDeleteOpenOrder (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotDeleteOpenOrder", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateSpotDeleteOrderOrderId (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateSpotDeleteOrderOrderId", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1EntrustPlanDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1EntrustPlanDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1EntrustPlanList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1EntrustPlanList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1EntrustPlanListHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1EntrustPlanListHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1EntrustProfitDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1EntrustProfitDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1EntrustProfitList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1EntrustProfitList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1OrderDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1OrderDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1OrderList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1OrderList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1OrderListHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1OrderListHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureTradeV1OrderTradeList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureTradeV1OrderTradeList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1AccountInfo (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1AccountInfo", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1BalanceBills (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1BalanceBills", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1BalanceDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1BalanceDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1BalanceFundingRateList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1BalanceFundingRateList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1BalanceList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1BalanceList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1PositionAdl (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1PositionAdl", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1PositionList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1PositionList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1UserCollectionList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1UserCollectionList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearGetFutureUserV1UserListenKey (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearGetFutureUserV1UserListenKey", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCancelAllPlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCancelAllPlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCancelAllProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCancelAllProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCancelPlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCancelPlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCancelProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCancelProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCreatePlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCreatePlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustCreateProfit (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustCreateProfit", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1EntrustUpdateProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1EntrustUpdateProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1OrderCancel (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1OrderCancel", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1OrderCancelAll (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1OrderCancelAll", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1OrderCreate (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1OrderCreate", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureTradeV1OrderCreateBatch (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureTradeV1OrderCreateBatch", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1AccountOpen (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1AccountOpen", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1PositionAdjustLeverage (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1PositionAdjustLeverage", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1PositionAutoMargin (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1PositionAutoMargin", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1PositionCloseAll (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1PositionCloseAll", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1PositionMargin (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1PositionMargin", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1UserCollectionAdd (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1UserCollectionAdd", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1UserCollectionCancel (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1UserCollectionCancel", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateLinearPostFutureUserV1PositionChangeType (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateLinearPostFutureUserV1PositionChangeType", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1EntrustPlanDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1EntrustPlanDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1EntrustPlanList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1EntrustPlanList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1EntrustPlanListHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1EntrustPlanListHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1EntrustProfitDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1EntrustProfitDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1EntrustProfitList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1EntrustProfitList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1OrderDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1OrderDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1OrderList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1OrderList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1OrderListHistory (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1OrderListHistory", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureTradeV1OrderTradeList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureTradeV1OrderTradeList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1AccountInfo (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1AccountInfo", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1BalanceBills (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1BalanceBills", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1BalanceDetail (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1BalanceDetail", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1BalanceFundingRateList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1BalanceFundingRateList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1BalanceList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1BalanceList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1PositionAdl (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1PositionAdl", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1PositionList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1PositionList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1UserCollectionList (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1UserCollectionList", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInverseGetFutureUserV1UserListenKey (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInverseGetFutureUserV1UserListenKey", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCancelAllPlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCancelAllPlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCancelAllProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCancelAllProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCancelPlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCancelPlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCancelProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCancelProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCreatePlan (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCreatePlan", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustCreateProfit (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustCreateProfit", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1EntrustUpdateProfitStop (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1EntrustUpdateProfitStop", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1OrderCancel (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1OrderCancel", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1OrderCancelAll (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1OrderCancelAll", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1OrderCreate (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1OrderCreate", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureTradeV1OrderCreateBatch (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureTradeV1OrderCreateBatch", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1AccountOpen (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1AccountOpen", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1PositionAdjustLeverage (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1PositionAdjustLeverage", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1PositionAutoMargin (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1PositionAutoMargin", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1PositionCloseAll (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1PositionCloseAll", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1PositionMargin (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1PositionMargin", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1UserCollectionAdd (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1UserCollectionAdd", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateInversePostFutureUserV1UserCollectionCancel (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateInversePostFutureUserV1UserCollectionCancel", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserGetUserAccount (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserGetUserAccount", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserGetUserAccountApiKey (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserGetUserAccountApiKey", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserPostUserAccount (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserPostUserAccount", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserPostUserAccountApiKey (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserPostUserAccountApiKey", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserPutUserAccountApiKey (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserPutUserAccountApiKey", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (this *xt) PrivateUserDeleteUserAccountApikeyId (args ...interface{}) <-chan interface{} {
|
|
parameters := GetArg(args, 0, nil)
|
|
ch := make(chan interface{})
|
|
go func() {
|
|
defer close(ch)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ch <- "panic:" + ToString(r)
|
|
}
|
|
}()
|
|
ch <- (<-this.callEndpoint ("privateUserDeleteUserAccountApikeyId", parameters))
|
|
PanicOnError(ch)
|
|
}()
|
|
return ch
|
|
}
|