Skip to content

Commit

Permalink
GateIO: Abstract GetOpenInterest
Browse files Browse the repository at this point in the history
  • Loading branch information
@gbjk
gbjk committed Jan 5, 2025
1 parent e67c5cf commit 3f40669
Showing 1 changed file with 56 additions and 122 deletions.
178 changes: 56 additions & 122 deletions exchanges/gateio/gateio_wrapper.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2200,138 +2200,72 @@ func contractToFundingRate(name string, item asset.Item, fPair currency.Pair, co
}

// GetOpenInterest returns the open interest rate for a given asset pair
func (g *Gateio) GetOpenInterest(ctx context.Context, k ...key.PairAsset) ([]futures.OpenInterest, error) {
for i := range k {
if k[i].Asset != asset.DeliveryFutures && k[i].Asset != asset.Futures {
// avoid API calls or returning errors after a successful retrieval
return nil, fmt.Errorf("%w %v %v", asset.ErrNotSupported, k[i].Asset, k[i].Pair())
}
}
if len(k) == 1 {
p, isEnabled, err := g.MatchSymbolCheckEnabled(k[0].Pair().String(), k[0].Asset, false)
// If no pairs are provided, all enabled pairs will be used
func (g *Gateio) GetOpenInterest(ctx context.Context, keys ...key.PairAsset) ([]futures.OpenInterest, error) {
var errs error
for _, a := range []asset.Item{asset.DeliveryFutures, asset.CoinMarginedFutures, asset.USDTMarginedFutures} {
pairs, err := g.GetEnabledPairs(a)
if err != nil {
return nil, err
}
if !isEnabled {
return nil, fmt.Errorf("%w: %v", currency.ErrPairNotEnabled, k[0].Pair())
continue
}
switch k[0].Asset {
case asset.DeliveryFutures:
contractResp, err := g.GetDeliveryContract(ctx, currency.USDT, p)
if err != nil {
return nil, err
if len(keys) == 0 {
for _, p := range pairs {
keys = append(keys, key.PairAsset{
Asset: a,
Base: p.Base.Item,
Quote: p.Quote.Item,
})
}
openInterest := contractResp.QuantoMultiplier.Float64() * float64(contractResp.PositionSize) * contractResp.IndexPrice.Float64()
return []futures.OpenInterest{
{
Key: key.ExchangePairAsset{
Exchange: g.Name,
Base: k[0].Base,
Quote: k[0].Quote,
Asset: k[0].Asset,
},
OpenInterest: openInterest,
},
}, nil
case asset.Futures:
for _, s := range settlementCurrencies {
contractResp, err := g.GetFuturesContract(ctx, s, p.String())
if err != nil {
continue
} else {
for _, k := range keys {
if p := k.Pair(); !pairs.Contains(p, true) {
return nil, fmt.Errorf("%w: %s %s", currency.ErrPairNotEnabled, a, p)
}
openInterest := contractResp.QuantoMultiplier.Float64() * float64(contractResp.PositionSize) * contractResp.IndexPrice.Float64()
return []futures.OpenInterest{
{
Key: key.ExchangePairAsset{
Exchange: g.Name,
Base: k[0].Base,
Quote: k[0].Quote,
Asset: k[0].Asset,
},
OpenInterest: openInterest,
},
}, nil
}
}
}
var resp []futures.OpenInterest
for _, a := range g.GetAssetTypes(true) {
switch a {
resp := make([]futures.OpenInterest, 0, len(keys))
for _, k := range keys {
p, isEnabled, err := g.MatchSymbolCheckEnabled(k.Pair().String(), k.Asset, false)
if !isEnabled {
err = currency.ErrPairNotEnabled
}
if err != nil {
errs = common.AppendError(errs, err)
err = fmt.Errorf("%w: %s", asset.ErrNotEnabled, k.Pair())
continue
}
settlementCurrency := currency.USDT
var openInterest float64
switch k.Asset {
case asset.DeliveryFutures:
contractResp, err := g.GetAllDeliveryContracts(ctx, currency.USDT)
if err != nil {
return nil, err
}

for i := range contractResp {
p, isEnabled, err := g.MatchSymbolCheckEnabled(contractResp[i].Name, a, true)
if err != nil && !errors.Is(err, currency.ErrPairNotFound) {
return nil, err
}
if !isEnabled {
continue
}
var appendData bool
for j := range k {
if k[j].Pair().Equal(p) {
appendData = true
break
}
}
if len(k) > 0 && !appendData {
continue
}
openInterest := contractResp[i].QuantoMultiplier.Float64() * float64(contractResp[i].PositionSize) * contractResp[i].IndexPrice.Float64()
resp = append(resp, futures.OpenInterest{
Key: key.ExchangePairAsset{
Exchange: g.Name,
Base: p.Base.Item,
Quote: p.Quote.Item,
Asset: a,
},
OpenInterest: openInterest,
})
}
case asset.Futures:
for _, s := range settlementCurrencies {
contractResp, err := g.GetAllFutureContracts(ctx, s)
if err != nil {
return nil, err
}

for i := range contractResp {
p, isEnabled, err := g.MatchSymbolCheckEnabled(contractResp[i].Name, a, true)
if err != nil && !errors.Is(err, currency.ErrPairNotFound) {
return nil, err
}
if !isEnabled {
continue
}
var appendData bool
for j := range k {
if k[j].Pair().Equal(p) {
appendData = true
break
}
}
if len(k) > 0 && !appendData {
continue
}
openInterest := contractResp[i].QuantoMultiplier.Float64() * float64(contractResp[i].PositionSize) * contractResp[i].IndexPrice.Float64()
resp = append(resp, futures.OpenInterest{
Key: key.ExchangePairAsset{
Exchange: g.Name,
Base: p.Base.Item,
Quote: p.Quote.Item,
Asset: a,
},
OpenInterest: openInterest,
})
}
}
contractResp, err2 := g.GetDeliveryContract(ctx, currency.USDT, p)
err = err2
openInterest = contractResp.QuantoMultiplier.Float64() * float64(contractResp.PositionSize) * contractResp.IndexPrice.Float64()
case asset.CoinMarginedFutures:
settlementCurrency = currency.BTC
fallthrough
case asset.USDTMarginedFutures:
contractResp, err2 := g.GetFuturesContract(ctx, settlementCurrency, p.String())
err = err2
openInterest = contractResp.QuantoMultiplier.Float64() * float64(contractResp.PositionSize) * contractResp.IndexPrice.Float64()
default:
err = fmt.Errorf("%w %s %s", asset.ErrNotSupported, k.Asset, k.Pair())
}
if err != nil {
return nil, err
}
resp = append(resp, futures.OpenInterest{
Key: key.ExchangePairAsset{
Exchange: g.Name,
Base: k.Base,
Quote: k.Quote,
Asset: k.Asset,
},
OpenInterest: openInterest,
})
}
return resp, nil
return slices.Clip(resp), errs
}

// getClientOrderIDFromText returns the client order ID from the text response
Expand Down

0 comments on commit 3f40669

Please sign in to comment.