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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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