ccxt-go/gateio_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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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 *gateio) 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
}