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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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