d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-06-02 23:16:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

kline/exchanges: automatic creation of unsupported candle intervals (#1091)

Browse Source 
* kline: Add builder and testing

* Ideas

* kline: deploy builder functionality across GCT

* exchanges: implement across gct

* exchanges: Add tests and fix implementations before kline package testing and veri.

* kline: Add tests and start to fix ConvertToNewInterval

* kline: fix ConvertToNewInterval add tests

* kline: complete overarching tests now on to exchanges

* kline: finish exchange tests and implement limits

* exchanges: more fixes

* linter: fix

* engine: fix tests

* kraken: fix recent trades and other fixes

* zb: fix tests

* bithumb: fix empty insertion

* kline: refactor/optimize CreateKline function

* kline: remove the mooos!

* kline: prealloc CalculateCandleDateRanges

* linter: fix

* exchanges: prealloc extended

* fix whoopsie

* reverse fix because this is a whoopsie

* okx: fix risidual issues

* linter: fix

* kline: initial nits from @gloriouscode

* kline: rename builder -> request and cascade change

* linter: fix + test

* kline: update forced alignment on start and end times when CreateKlineRequest is called.

* nits: more more more

* NITS: Addressed

* tests: fix race issue

* Update exchanges/kline/request.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* kline: add method AddPadding() to automatically fill in holes in kline.Request functionality and reject if missing data when converting

* kline: Add params start and end to addPadding() to insert blanks in between block

* kline: remove test comment code as it's not needed anymore

* kline: fix lint and test

* kline: sort slice without extra bool check every iteration

* okx: fix issues with timeing and candles and such from niterinos & address typo

* Update exchanges/kline/kline.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: niterinos

* Update exchanges/poloniex/poloniex_wrapper.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits now onto conflicts YAYA!!!

* Update exchanges/exchange_test.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits again

* thrasher: nitters

* thrasher: niterinos - adds partial flag for incomplete recent candles and fetching.

* kline: rm fmtizzle packageizzle

* glorious: nitters

* glorious: more niterinos

* fix last niterinos

Co-authored-by: Ryan O'Hara-Reid <ryan.oharareid@thrasher.io>
Co-authored-by: Scott <gloriousCode@users.noreply.github.com>
This commit is contained in:
Ryan O'Hara-Reid
2023-01-17 16:22:33 +11:00
committed by GitHub
parent 72f36d70d1
commit 83cfefa45c
110 changed files with 11312 additions and 5768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
exchanges/bybit/bybit.go
View File

@@ -224,88 +224,89 @@ func (by *Bybit) GetKlines(ctx context.Context, symbol, period string, limit int
klines := make([]KlineItem, len(resp.Data))
for x := range resp.Data {
if len(resp.Data[x]) != 11 {
return klines, fmt.Errorf("%v GetKlines: invalid response, array length not as expected, check api docs for updates", by.Name)
return nil, fmt.Errorf("%v GetKlines: invalid response, array length not as expected, check api docs for updates", by.Name)
}
var kline KlineItem
var err error
startTime, ok := resp.Data[x][0].(float64)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for StartTime", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for StartTime", by.Name, errTypeAssert)
}
kline.StartTime = time.UnixMilli(int64(startTime))
klines[x].StartTime = time.UnixMilli(int64(startTime))
open, ok := resp.Data[x][1].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for Open", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for Open", by.Name, errTypeAssert)
}
kline.Open, err = strconv.ParseFloat(open, 64)
klines[x].Open, err = strconv.ParseFloat(open, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for Open", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for Open", by.Name, errStrParsing)
}
high, ok := resp.Data[x][2].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for High", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for High", by.Name, errTypeAssert)
}
kline.High, err = strconv.ParseFloat(high, 64)
klines[x].High, err = strconv.ParseFloat(high, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for High", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for High", by.Name, errStrParsing)
}
low, ok := resp.Data[x][3].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for Low", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for Low", by.Name, errTypeAssert)
}
kline.Low, err = strconv.ParseFloat(low, 64)
klines[x].Low, err = strconv.ParseFloat(low, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for Low", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for Low", by.Name, errStrParsing)
}
c, ok := resp.Data[x][4].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for Close", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for Close", by.Name, errTypeAssert)
}
kline.Close, err = strconv.ParseFloat(c, 64)
klines[x].Close, err = strconv.ParseFloat(c, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for Close", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for Close", by.Name, errStrParsing)
}
volume, ok := resp.Data[x][5].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for Volume", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for Volume", by.Name, errTypeAssert)
}
kline.Volume, err = strconv.ParseFloat(volume, 64)
klines[x].Volume, err = strconv.ParseFloat(volume, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for Volume", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for Volume", by.Name, errStrParsing)
}
endTime, ok := resp.Data[x][6].(float64)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for EndTime", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for EndTime", by.Name, errTypeAssert)
}
kline.EndTime = time.UnixMilli(int64(endTime))
klines[x].EndTime = time.UnixMilli(int64(endTime))
quoteAssetVolume, ok := resp.Data[x][7].(string)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for QuoteAssetVolume", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for QuoteAssetVolume", by.Name, errTypeAssert)
}
kline.QuoteAssetVolume, err = strconv.ParseFloat(quoteAssetVolume, 64)
klines[x].QuoteAssetVolume, err = strconv.ParseFloat(quoteAssetVolume, 64)
if err != nil {
return klines, fmt.Errorf("%v GetKlines: %w for QuoteAssetVolume", by.Name, errStrParsing)
return nil, fmt.Errorf("%v GetKlines: %w for QuoteAssetVolume", by.Name, errStrParsing)
}
tradesCount, ok := resp.Data[x][8].(float64)
if !ok {
return klines, fmt.Errorf("%v GetKlines: %w for TradesCount", by.Name, errTypeAssert)
return nil, fmt.Errorf("%v GetKlines: %w for TradesCount", by.Name, errTypeAssert)
}
kline.TradesCount = int64(tradesCount)
klines[x].TradesCount = int64(tradesCount)
if kline.TakerBaseVolume, ok = resp.Data[x][9].(float64); !ok {
return klines, fmt.Errorf("%v GetKlines: %w for TakerBaseVolume", by.Name, errTypeAssert)
klines[x].TakerBaseVolume, ok = resp.Data[x][9].(float64)
if !ok {
return nil, fmt.Errorf("%v GetKlines: %w for TakerBaseVolume", by.Name, errTypeAssert)
}
if kline.TakerQuoteVolume, ok = resp.Data[x][10].(float64); !ok {
return klines, fmt.Errorf("%v GetKlines: %w for TakerQuoteVolume", by.Name, errTypeAssert)
klines[x].TakerQuoteVolume, ok = resp.Data[x][10].(float64)
if !ok {
return nil, fmt.Errorf("%v GetKlines: %w for TakerQuoteVolume", by.Name, errTypeAssert)
}
klines[x] = kline
}
return klines, nil
}

34
exchanges/bybit/bybit_test.go
View File

@@ -55,6 +55,11 @@ func TestMain(m *testing.M) {
log.Fatal(err)
}
err = b.UpdateTradablePairs(context.Background(), false)
if err != nil {
log.Fatal(err)
}
os.Exit(m.Run())
}
@@ -2317,16 +2322,15 @@ func TestGetHistoricCandles(t *testing.T) {
if err != nil {
t.Fatal(err)
}
end := time.Now()
start := end.AddDate(0, 0, -3)
startTime := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, startTime, end, kline.OneDay)
_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, start, end)
if err != nil {
t.Error(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair, asset.USDTMarginedFutures, startTime, end, kline.OneDay)
_, err = b.GetHistoricCandles(context.Background(), pair, asset.USDTMarginedFutures, kline.OneDay, start, end)
if err != nil {
t.Error(err)
}
@@ -2336,17 +2340,17 @@ func TestGetHistoricCandles(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair1, asset.CoinMarginedFutures, startTime, end, kline.OneMin)
_, err = b.GetHistoricCandles(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, start, end)
if err != nil {
t.Error(err)
}
pair2, err := currency.NewPairFromString("BTCUSD-Z22")
enabled, err := b.GetEnabledPairs(asset.Futures)
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair2, asset.Futures, startTime, end, kline.OneMin)
_, err = b.GetHistoricCandles(context.Background(), enabled[0], asset.Futures, kline.OneHour, start, end)
if err != nil {
t.Error(err)
}
@@ -2356,7 +2360,7 @@ func TestGetHistoricCandles(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair3, asset.USDCMarginedFutures, startTime, end, kline.OneDay)
_, err = b.GetHistoricCandles(context.Background(), pair3, asset.USDCMarginedFutures, kline.OneDay, start, end)
if err != nil {
t.Error(err)
}
@@ -2372,12 +2376,12 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
startTime := time.Now().Add(-time.Hour * 24 * 3)
end := time.Now().Add(-time.Hour * 1)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, startTime, end, kline.OneMin)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneMin, startTime, end)
if err != nil {
t.Error(err)
}
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.USDTMarginedFutures, startTime, end, kline.OneMin)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.USDTMarginedFutures, kline.OneMin, startTime, end)
if err != nil {
t.Error(err)
}
@@ -2387,17 +2391,17 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandlesExtended(context.Background(), pair1, asset.CoinMarginedFutures, startTime, end, kline.OneHour)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, startTime, end)
if err != nil {
t.Error(err)
}
pair2, err := currency.NewPairFromString("BTCUSD-Z22")
enabled, err := b.GetEnabledPairs(asset.Futures)
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricCandlesExtended(context.Background(), pair2, asset.Futures, startTime, end, kline.OneDay)
_, err = b.GetHistoricCandlesExtended(context.Background(), enabled[0], asset.Futures, kline.OneDay, startTime, end)
if err != nil {
t.Error(err)
}
@@ -2407,7 +2411,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandlesExtended(context.Background(), pair3, asset.USDCMarginedFutures, startTime, end, kline.FiveMin)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair3, asset.USDCMarginedFutures, kline.FiveMin, startTime, end)
if err != nil {
t.Error(err)
}

221
exchanges/bybit/bybit_wrapper.go
View File

@@ -135,21 +135,21 @@ func (by *Bybit) SetDefaults() {
Enabled: exchange.FeaturesEnabled{
AutoPairUpdates: true,
Kline: kline.ExchangeCapabilitiesEnabled{
Intervals: map[string]bool{
kline.OneMin.Word(): true,
kline.ThreeMin.Word(): true,
kline.FiveMin.Word(): true,
kline.FifteenMin.Word(): true,
kline.ThirtyMin.Word(): true,
kline.OneHour.Word(): true,
kline.TwoHour.Word(): true,
kline.FourHour.Word(): true,
kline.SixHour.Word(): true,
kline.TwelveHour.Word(): true,
kline.OneDay.Word(): true,
kline.OneWeek.Word(): true,
kline.OneMonth.Word(): true,
},
Intervals: kline.DeployExchangeIntervals(
kline.OneMin,
kline.ThreeMin,
kline.FiveMin,
kline.FifteenMin,
kline.ThirtyMin,
kline.OneHour,
kline.TwoHour,
kline.FourHour,
kline.SixHour,
kline.TwelveHour,
kline.OneDay,
kline.OneWeek,
kline.OneMonth,
),
ResultLimit: 200,
},
},
@@ -1827,135 +1827,133 @@ func (by *Bybit) FormatExchangeKlineIntervalFutures(ctx context.Context, interva
}
// GetHistoricCandles returns candles between a time period for a set time interval
func (by *Bybit) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
if err := by.ValidateKline(pair, a, interval); err != nil {
return kline.Item{}, err
}
klineItem := kline.Item{
Exchange: by.Name,
Pair: pair,
Asset: a,
Interval: interval,
}
formattedPair, err := by.FormatExchangeCurrency(pair, a)
func (by *Bybit) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error) {
req, err := by.GetKlineRequest(pair, a, interval, start, end)
if err != nil {
return klineItem, err
return nil, err
}
switch a {
var timeSeries []kline.Candle
switch req.Asset {
case asset.Spot:
candles, err := by.GetKlines(ctx, formattedPair.String(), by.FormatExchangeKlineInterval(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), start, end)
var candles []KlineItem
candles, err = by.GetKlines(ctx,
req.RequestFormatted.String(),
by.FormatExchangeKlineInterval(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Start,
req.End)
if err != nil {
return klineItem, err
return nil, err
}
timeSeries = make([]kline.Candle, len(candles))
for x := range candles {
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries[x] = kline.Candle{
Time: candles[x].StartTime,
Open: candles[x].Open,
High: candles[x].High,
Low: candles[x].Low,
Close: candles[x].Close,
Volume: candles[x].Volume,
})
}
}
case asset.CoinMarginedFutures, asset.Futures:
candles, err := by.GetFuturesKlineData(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), start)
var candles []FuturesCandleStickWithStringParam
candles, err = by.GetFuturesKlineData(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Start)
if err != nil {
return klineItem, err
return nil, err
}
timeSeries = make([]kline.Candle, len(candles))
for x := range candles {
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries[x] = kline.Candle{
Time: time.Unix(candles[x].OpenTime, 0),
Open: candles[x].Open,
High: candles[x].High,
Low: candles[x].Low,
Close: candles[x].Close,
Volume: candles[x].Volume,
})
}
}
case asset.USDTMarginedFutures:
candles, err := by.GetUSDTFuturesKlineData(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), start)
var candles []FuturesCandleStick
candles, err = by.GetUSDTFuturesKlineData(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Start)
if err != nil {
return klineItem, err
return nil, err
}
timeSeries = make([]kline.Candle, len(candles))
for x := range candles {
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries[x] = kline.Candle{
Time: time.Unix(candles[x].OpenTime, 0),
Open: candles[x].Open,
High: candles[x].High,
Low: candles[x].Low,
Close: candles[x].Close,
Volume: candles[x].Volume,
})
}
}
case asset.USDCMarginedFutures:
candles, err := by.GetUSDCKlines(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), start, int64(by.Features.Enabled.Kline.ResultLimit))
var candles []USDCKline
candles, err = by.GetUSDCKlines(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
req.Start,
int64(by.Features.Enabled.Kline.ResultLimit))
if err != nil {
return klineItem, err
return nil, err
}
timeSeries = make([]kline.Candle, len(candles))
for x := range candles {
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries[x] = kline.Candle{
Time: candles[x].OpenTime.Time(),
Open: candles[x].Open,
High: candles[x].High,
Low: candles[x].Low,
Close: candles[x].Close,
Volume: candles[x].Volume,
})
}
}
default:
return klineItem, fmt.Errorf("%s %w", a, asset.ErrNotSupported)
return nil, fmt.Errorf("%s %w", req.Asset, asset.ErrNotSupported)
}
klineItem.RemoveOutsideRange(start, end)
klineItem.SortCandlesByTimestamp(false)
return klineItem, nil
return req.ProcessResponse(timeSeries)
}
// GetHistoricCandlesExtended returns candles between a time period for a set time interval
func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
if err := by.ValidateKline(pair, a, interval); err != nil {
return kline.Item{}, err
}
klineItem := kline.Item{
Exchange: by.Name,
Pair: pair,
Asset: a,
Interval: interval,
}
formattedPair, err := by.FormatExchangeCurrency(pair, a)
func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error) {
req, err := by.GetKlineExtendedRequest(pair, a, interval, start, end)
if err != nil {
return klineItem, err
return nil, err
}
dates, err := kline.CalculateCandleDateRanges(start, end, interval, by.Features.Enabled.Kline.ResultLimit)
if err != nil {
return kline.Item{}, err
}
for x := range dates.Ranges {
switch a {
timeSeries := make([]kline.Candle, 0, req.Size())
for x := range req.Ranges {
switch req.Asset {
case asset.Spot:
candles, err := by.GetKlines(ctx, formattedPair.String(), by.FormatExchangeKlineInterval(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), dates.Ranges[x].Start.Time, dates.Ranges[x].End.Time)
var candles []KlineItem
candles, err = by.GetKlines(ctx,
req.RequestFormatted.String(),
by.FormatExchangeKlineInterval(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Ranges[x].Start.Time,
req.Ranges[x].End.Time)
if err != nil {
return kline.Item{}, err
return nil, err
}
for i := range candles {
for j := range klineItem.Candles {
if klineItem.Candles[j].Time.Equal(candles[i].StartTime) {
continue
}
}
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries = append(timeSeries, kline.Candle{
Time: candles[i].StartTime,
Open: candles[i].Open,
High: candles[i].High,
@@ -1965,18 +1963,18 @@ func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.P
})
}
case asset.CoinMarginedFutures, asset.Futures:
candles, err := by.GetFuturesKlineData(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), dates.Ranges[x].Start.Time)
var candles []FuturesCandleStickWithStringParam
candles, err = by.GetFuturesKlineData(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Ranges[x].Start.Time)
if err != nil {
return kline.Item{}, err
return nil, err
}
for i := range candles {
for j := range klineItem.Candles {
if klineItem.Candles[j].Time.Equal(time.Unix(candles[i].OpenTime, 0)) {
continue
}
}
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries = append(timeSeries, kline.Candle{
Time: time.Unix(candles[i].OpenTime, 0),
Open: candles[i].Open,
High: candles[i].High,
@@ -1986,18 +1984,18 @@ func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.P
})
}
case asset.USDTMarginedFutures:
candles, err := by.GetUSDTFuturesKlineData(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), int64(by.Features.Enabled.Kline.ResultLimit), dates.Ranges[x].Start.Time)
var candles []FuturesCandleStick
candles, err = by.GetUSDTFuturesKlineData(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
int64(by.Features.Enabled.Kline.ResultLimit),
req.Ranges[x].Start.Time)
if err != nil {
return kline.Item{}, err
return nil, err
}
for i := range candles {
for j := range klineItem.Candles {
if klineItem.Candles[j].Time.Equal(time.Unix(candles[i].OpenTime, 0)) {
continue
}
}
klineItem.Candles = append(klineItem.Candles, kline.Candle{
timeSeries = append(timeSeries, kline.Candle{
Time: time.Unix(candles[i].OpenTime, 0),
Open: candles[i].Open,
High: candles[i].High,
@@ -2007,18 +2005,18 @@ func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.P
})
}
case asset.USDCMarginedFutures:
candles, err := by.GetUSDCKlines(ctx, formattedPair, by.FormatExchangeKlineIntervalFutures(ctx, interval), dates.Ranges[x].Start.Time, int64(by.Features.Enabled.Kline.ResultLimit))
var candles []USDCKline
candles, err = by.GetUSDCKlines(ctx,
req.RequestFormatted,
by.FormatExchangeKlineIntervalFutures(ctx, req.ExchangeInterval),
req.Ranges[x].Start.Time,
int64(by.Features.Enabled.Kline.ResultLimit))
if err != nil {
return klineItem, err
return nil, err
}
for i := range candles {
for j := range klineItem.Candles {
if klineItem.Candles[j].Time.Equal(candles[i].OpenTime.Time()) {
continue
}
}
klineItem.Candles = append(klineItem.Candles, kline.Candle{
for x := range candles {
timeSeries = append(timeSeries, kline.Candle{
Time: candles[x].OpenTime.Time(),
Open: candles[x].Open,
High: candles[x].High,
@@ -2028,19 +2026,10 @@ func (by *Bybit) GetHistoricCandlesExtended(ctx context.Context, pair currency.P
})
}
default:
return kline.Item{}, fmt.Errorf("%s %w", a, asset.ErrNotSupported)
return nil, fmt.Errorf("%s %w", req.Asset, asset.ErrNotSupported)
}
}
dates.SetHasDataFromCandles(klineItem.Candles)
summary := dates.DataSummary(false)
if len(summary) > 0 {
log.Warnf(log.ExchangeSys, "%v - %v", by.Name, summary)
}
klineItem.RemoveDuplicateCandlesByTime()
klineItem.RemoveOutsideRange(start, end)
klineItem.SortCandlesByTimestamp(false)
return klineItem, nil
return req.ProcessResponse(timeSeries)
}
// GetServerTime returns the current exchange server time.