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

exchanges/futures: Implement open interest (#1417)

Browse Source 
* adds open interest to exchanges

* ADDS TESTING YEAH

* New endpoints, BTSE, RPCS, cached

* slight design change, begin gateio

You will need to get cached for
each exchange that supports it

* gateio, huobi, rpc

* fix up kraken, cache retrieval

* okx, gateio

* finalising all implementations and tests

* definitely my final ever commit on this

* Well, well, well

* final v2

* quick fix of bug

* test coverage, assert notempty, test helper

Added a new testhelper for currency
management because its very annoying
in a parallel test setting which wastes
so much space otherwise

* minimises REST requests for Open Interest

* types.Number merge misses

* Minimises Kraken REST calls

* len change, value -> pointer receiver

* further fixup

* fixes gateio, batch calculates open interest

* single gateio, lint const fixes

* rejig and more thorough oi for huobi

* formatting expansion

* minor fix for handling expiring contracts

* rm unused Binance strings

* add bybit support, fix bybit issues

* oopsie doopsie, dont look at my whoopsie

* Fix issue, remove feature

* move an irrelevant function for the pr

* mini bybit upgrades

* fixes cli request bug
This commit is contained in:
Scott
2024-01-12 15:27:35 +11:00
committed by GitHub
parent 614042110a
commit b71bf1f3d1
62 changed files with 22660 additions and 10095 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
exchanges/gateio/gateio_wrapper.go
View File

@@ -13,6 +13,7 @@ import (
"github.com/shopspring/decimal"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/common/key"
"github.com/thrasher-corp/gocryptotrader/config"
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -124,6 +125,10 @@ func (g *Gateio) SetDefaults() {
FundingRateBatching: map[asset.Item]bool{
asset.Futures: true,
},
OpenInterest: exchange.OpenInterestSupport{
Supported: true,
SupportsRestBatch: true,
},
},
},
Enabled: exchange.FeaturesEnabled{
@@ -2343,3 +2348,138 @@ func contractToFundingRate(name string, item asset.Item, fPair currency.Pair, co
func (g *Gateio) IsPerpetualFutureCurrency(a asset.Item, _ currency.Pair) (bool, error) {
return a == asset.Futures, nil
}
// 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 err != nil {
return nil, err
}
if !isEnabled {
return nil, fmt.Errorf("%w %v", asset.ErrNotEnabled, k[0].Pair())
}
switch k[0].Asset {
case asset.DeliveryFutures:
contractResp, err := g.GetSingleDeliveryContracts(ctx, "usdt", p)
if err != nil {
return nil, err
}
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 []string{"usd", "usdt", "btc"} {
contractResp, err := g.GetSingleContract(ctx, s, p.String())
if err != nil {
continue
}
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 {
case asset.DeliveryFutures:
contractResp, err := g.GetAllDeliveryContracts(ctx, "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 []string{"usd", "usdt", "btc"} {
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,
})
}
}
}
}
return resp, nil
}