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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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