ccxt-go/gate_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 *gate) PublicWalletGetCurrencyChains (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicWalletGetCurrencyChains", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *gate) 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 *gate) PublicSpotGetCurrenciesCurrency (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicSpotGetCurrenciesCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

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

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

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

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

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

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

func (this *gate) 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 *gate) PublicMarginGetCurrencyPairs (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicMarginGetCurrencyPairs", parameters))
       PanicOnError(ch)
   }()
   return ch
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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