d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-21 15:10:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Kraken: Simplify REST error and result handling (#1591)

Browse Source 
* Kraken: Simplify REST error and result handling

* Kraken: Rid excessive map lookups or large copies when iterating

* Kraken: Prealloc orderbook types.Numer size

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

---------

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>
This commit is contained in:
Adrian Gallagher
2024-07-29 12:36:38 +10:00
committed by GitHub
parent ba3dcc8e25
commit 0c5d049b05
5 changed files with 379 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

591
exchanges/kraken/kraken.go
View File

@@ -22,6 +22,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/request"
"github.com/thrasher-corp/gocryptotrader/log"
"github.com/thrasher-corp/gocryptotrader/types"
)
const (
@@ -41,19 +42,15 @@ type Kraken struct {
}
// GetCurrentServerTime returns current server time
func (k *Kraken) GetCurrentServerTime(ctx context.Context) (TimeResponse, error) {
func (k *Kraken) GetCurrentServerTime(ctx context.Context) (*TimeResponse, error) {
path := fmt.Sprintf("/%s/public/%s", krakenAPIVersion, krakenServerTime)
var response struct {
Error []string `json:"error"`
Result TimeResponse `json:"result"`
var result TimeResponse
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result); err != nil {
return nil, err
}
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// SeedAssets seeds Kraken's asset list and stores it in the
@@ -71,8 +68,8 @@ func (k *Kraken) SeedAssets(ctx context.Context) error {
if err != nil {
return err
}
for k := range assetPairs {
assetTranslator.Seed(k, assetPairs[k].Altname)
for k, v := range assetPairs {
assetTranslator.Seed(k, v.Altname)
}
return nil
}
@@ -80,16 +77,11 @@ func (k *Kraken) SeedAssets(ctx context.Context) error {
// GetAssets returns a full asset list
func (k *Kraken) GetAssets(ctx context.Context) (map[string]*Asset, error) {
path := fmt.Sprintf("/%s/public/%s", krakenAPIVersion, krakenAssets)
var response struct {
Error []string `json:"error"`
Result map[string]*Asset `json:"result"`
var result map[string]*Asset
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result); err != nil {
return nil, err
}
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetAssetPairs returns a full asset pair list
@@ -102,62 +94,50 @@ func (k *Kraken) GetAssetPairs(ctx context.Context, assetPairs []string, info st
assets = strings.Join(assetPairs, ",")
params.Set("pair", assets)
}
var response struct {
Error []string `json:"error"`
Result map[string]*AssetPairs `json:"result"`
}
var result map[string]*AssetPairs
if info != "" {
if info != "margin" && info != "leverage" && info != "fees" && info != "info" {
return response.Result, errors.New("parameter info can only be 'asset', 'margin', 'fees' or 'leverage'")
return nil, errors.New("parameter info can only be 'asset', 'margin', 'fees' or 'leverage'")
}
params.Set("info", info)
}
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path+params.Encode(), &response); err != nil {
return response.Result, err
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path+params.Encode(), &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetTicker returns ticker information from kraken
func (k *Kraken) GetTicker(ctx context.Context, symbol currency.Pair) (Ticker, error) {
tick := Ticker{}
func (k *Kraken) GetTicker(ctx context.Context, symbol currency.Pair) (*Ticker, error) {
values := url.Values{}
symbolValue, err := k.FormatSymbol(symbol, asset.Spot)
if err != nil {
return tick, err
return nil, err
}
values.Set("pair", symbolValue)
type Response struct {
Error []interface{} `json:"error"`
Data map[string]TickerResponse `json:"result"`
}
resp := Response{}
var data map[string]*TickerResponse
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenTicker, values.Encode())
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &resp)
if err != nil {
return tick, err
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &data); err != nil {
return nil, err
}
if len(resp.Error) > 0 {
return tick, fmt.Errorf("%s error: %s", k.Name, resp.Error)
var tick Ticker
for _, v := range data {
tick.Ask = v.Ask[0].Float64()
tick.AskSize = v.Ask[2].Float64()
tick.Bid = v.Bid[0].Float64()
tick.BidSize = v.Bid[2].Float64()
tick.Last = v.Last[0].Float64()
tick.Volume = v.Volume[1].Float64()
tick.VolumeWeightedAveragePrice = v.VolumeWeightedAveragePrice[1].Float64()
tick.Trades = v.Trades[1]
tick.Low = v.Low[1].Float64()
tick.High = v.High[1].Float64()
tick.Open = v.Open.Float64()
}
for i := range resp.Data {
tick.Ask = resp.Data[i].Ask[0].Float64()
tick.AskSize = resp.Data[i].Ask[2].Float64()
tick.Bid = resp.Data[i].Bid[0].Float64()
tick.BidSize = resp.Data[i].Bid[2].Float64()
tick.Last = resp.Data[i].Last[0].Float64()
tick.Volume = resp.Data[i].Volume[1].Float64()
tick.VolumeWeightedAveragePrice = resp.Data[i].VolumeWeightedAveragePrice[1].Float64()
tick.Trades = resp.Data[i].Trades[1]
tick.Low = resp.Data[i].Low[1].Float64()
tick.High = resp.Data[i].High[1].Float64()
tick.Open = resp.Data[i].Open.Float64()
}
return tick, nil
return &tick, nil
}
// GetTickers supports fetching multiple tickers from Kraken
@@ -169,37 +149,28 @@ func (k *Kraken) GetTickers(ctx context.Context, pairList string) (map[string]Ti
values.Set("pair", pairList)
}
type Response struct {
Error []interface{} `json:"error"`
Data map[string]TickerResponse `json:"result"`
}
resp := Response{}
var result map[string]*TickerResponse
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenTicker, values.Encode())
err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &resp)
err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result)
if err != nil {
return nil, err
}
if len(resp.Error) > 0 {
return nil, fmt.Errorf("%s error: %s", k.Name, resp.Error)
}
tickers := make(map[string]Ticker, len(resp.Data))
for i := range resp.Data {
tickers[i] = Ticker{
Ask: resp.Data[i].Ask[0].Float64(),
AskSize: resp.Data[i].Ask[2].Float64(),
Bid: resp.Data[i].Bid[0].Float64(),
BidSize: resp.Data[i].Bid[2].Float64(),
Last: resp.Data[i].Last[0].Float64(),
Volume: resp.Data[i].Volume[1].Float64(),
VolumeWeightedAveragePrice: resp.Data[i].VolumeWeightedAveragePrice[1].Float64(),
Trades: resp.Data[i].Trades[1],
Low: resp.Data[i].Low[1].Float64(),
High: resp.Data[i].High[1].Float64(),
Open: resp.Data[i].Open.Float64(),
tickers := make(map[string]Ticker, len(result))
for k, v := range result {
tickers[k] = Ticker{
Ask: v.Ask[0].Float64(),
AskSize: v.Ask[2].Float64(),
Bid: v.Bid[0].Float64(),
BidSize: v.Bid[2].Float64(),
Last: v.Last[0].Float64(),
Volume: v.Volume[1].Float64(),
VolumeWeightedAveragePrice: v.VolumeWeightedAveragePrice[1].Float64(),
Trades: v.Trades[1],
Low: v.Low[1].Float64(),
High: v.High[1].Float64(),
Open: v.Open.Float64(),
}
}
return tickers, nil
@@ -218,25 +189,16 @@ func (k *Kraken) GetOHLC(ctx context.Context, symbol currency.Pair, interval str
}
values.Set("pair", translatedAsset)
values.Set("interval", interval)
type Response struct {
Error []interface{} `json:"error"`
Data map[string]interface{} `json:"result"`
}
var result Response
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenOHLC, values.Encode())
result := make(map[string]any)
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result)
if err != nil {
return nil, err
}
if len(result.Error) != 0 {
return nil, fmt.Errorf("getOHLC error: %s", result.Error)
}
ohlcData, ok := result.Data[translatedAsset].([]interface{})
ohlcData, ok := result[translatedAsset].([]interface{})
if !ok {
return nil, errors.New("invalid data returned")
}
@@ -253,9 +215,12 @@ func (k *Kraken) GetOHLC(ctx context.Context, symbol currency.Pair, interval str
}
var o OpenHighLowClose
if o.Time, ok = subData[0].(float64); !ok {
tmData, ok := subData[0].(float64)
if !ok {
return nil, errors.New("unable to type assert time")
}
o.Time = time.Unix(int64(tmData), 0)
if o.Open, err = convert.FloatFromString(subData[1]); err != nil {
return nil, err
}
@@ -291,74 +256,36 @@ func (k *Kraken) GetDepth(ctx context.Context, symbol currency.Pair) (*Orderbook
values := url.Values{}
values.Set("pair", symbolValue)
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenDepth, values.Encode())
var result interface{}
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result)
if err != nil {
type orderbookStructure struct {
Bids [][3]types.Number `json:"bids"`
Asks [][3]types.Number `json:"asks"`
}
result := make(map[string]*orderbookStructure)
if err := k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result); err != nil {
return nil, err
}
if result == nil {
return nil, fmt.Errorf("%s GetDepth result is nil", k.Name)
}
ob := new(Orderbook)
for _, v := range result {
ob.Asks = make([]OrderbookBase, len(v.Asks))
ob.Bids = make([]OrderbookBase, len(v.Bids))
data, ok := result.(map[string]interface{})
if !ok {
return nil, errors.New("unable to type assert data")
}
orderbookData, ok := data["result"].(map[string]interface{})
if !ok {
return nil, fmt.Errorf("%s GetDepth data[result] is nil", k.Name)
}
var bidsData []interface{}
var asksData []interface{}
for _, y := range orderbookData {
yData, ok := y.(map[string]interface{})
if !ok {
return nil, errors.New("unable to type assert yData")
for x := range v.Asks {
ob.Asks[x].Price = v.Asks[x][0]
ob.Asks[x].Amount = v.Asks[x][1]
ob.Asks[x].Timestamp = time.Unix(v.Asks[x][2].Int64(), 0)
}
if bidsData, ok = yData["bids"].([]interface{}); !ok {
return nil, errors.New("unable to type assert bidsData")
}
if asksData, ok = yData["asks"].([]interface{}); !ok {
return nil, errors.New("unable to type assert asksData")
for x := range v.Bids {
ob.Bids[x].Price = v.Bids[x][0]
ob.Bids[x].Amount = v.Bids[x][1]
ob.Bids[x].Timestamp = time.Unix(v.Bids[x][2].Int64(), 0)
}
}
processOrderbook := func(data []interface{}) ([]OrderbookBase, error) {
result := make([]OrderbookBase, len(data))
for x := range data {
entry, ok := data[x].([]interface{})
if !ok {
return nil, errors.New("unable to type assert entry")
}
if len(entry) < 2 {
return nil, errors.New("unexpected entry length")
}
price, priceErr := strconv.ParseFloat(entry[0].(string), 64)
if priceErr != nil {
return nil, priceErr
}
amount, amountErr := strconv.ParseFloat(entry[1].(string), 64)
if amountErr != nil {
return nil, amountErr
}
result[x] = OrderbookBase{Price: price, Amount: amount}
}
return result, nil
}
var orderBook Orderbook
orderBook.Bids, err = processOrderbook(bidsData)
if err != nil {
return nil, err
}
orderBook.Asks, err = processOrderbook(asksData)
return &orderBook, err
return ob, nil
}
// GetTrades returns current trades on Kraken
@@ -373,27 +300,13 @@ func (k *Kraken) GetTrades(ctx context.Context, symbol currency.Pair) ([]RecentT
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenTrades, values.Encode())
var data RecentTradesResponse
data := make(map[string]any)
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &data)
if err != nil {
return nil, err
}
if len(data.Error) > 0 {
var errs error
for x := range data.Error {
errString, ok := data.Error[x].(string)
if !ok {
continue
}
errs = common.AppendError(errs, errors.New(errString))
}
if errs != nil {
return nil, errs
}
}
trades, ok := data.Result[translatedAsset].([]interface{})
trades, ok := data[translatedAsset].([]interface{})
if !ok {
return nil, fmt.Errorf("no data returned for symbol %v", symbol)
}
@@ -452,16 +365,14 @@ func (k *Kraken) GetSpread(ctx context.Context, symbol currency.Pair) ([]Spread,
}
values.Set("pair", symbolValue)
resp := struct {
SpreadData map[string]interface{} `json:"result"`
}{}
result := make(map[string]any)
path := fmt.Sprintf("/%s/public/%s?%s", krakenAPIVersion, krakenSpread, values.Encode())
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &resp)
err = k.SendHTTPRequest(ctx, exchange.RestSpot, path, &result)
if err != nil {
return nil, err
}
data, ok := resp.SpreadData[symbolValue]
data, ok := result[symbolValue]
if !ok {
return nil, fmt.Errorf("unable to find %s in spread data", symbolValue)
}
@@ -502,73 +413,60 @@ func (k *Kraken) GetSpread(ctx context.Context, symbol currency.Pair) ([]Spread,
// GetBalance returns your balance associated with your keys
func (k *Kraken) GetBalance(ctx context.Context) (map[string]Balance, error) {
var response struct {
Error []string `json:"error"`
Result map[string]Balance `json:"result"`
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenBalance, url.Values{}, &response); err != nil {
var result map[string]Balance
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenBalance, url.Values{}, &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetWithdrawInfo gets withdrawal fees
func (k *Kraken) GetWithdrawInfo(ctx context.Context, currency string, amount float64) (WithdrawInformation, error) {
var response struct {
Error []string `json:"error"`
Result WithdrawInformation `json:"result"`
}
func (k *Kraken) GetWithdrawInfo(ctx context.Context, currency string, amount float64) (*WithdrawInformation, error) {
params := url.Values{}
params.Set("asset", currency)
params.Set("key", "")
params.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64))
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawInfo, params, &response); err != nil {
return response.Result, err
var result WithdrawInformation
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawInfo, params, &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// Withdraw withdraws funds
func (k *Kraken) Withdraw(ctx context.Context, asset, key string, amount float64) (string, error) {
var response struct {
Error []string `json:"error"`
ReferenceID string `json:"refid"`
}
params := url.Values{}
params.Set("asset", asset)
params.Set("key", key)
params.Set("amount", fmt.Sprintf("%f", amount))
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdraw, params, &response); err != nil {
return response.ReferenceID, err
var referenceID string
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdraw, params, &referenceID); err != nil {
return referenceID, err
}
return response.ReferenceID, GetError(response.Error)
return referenceID, nil
}
// GetDepositMethods gets withdrawal fees
func (k *Kraken) GetDepositMethods(ctx context.Context, currency string) ([]DepositMethods, error) {
var response struct {
Error []string `json:"error"`
Result []DepositMethods `json:"result"`
}
params := url.Values{}
params.Set("asset", currency)
err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenDepositMethods, params, &response)
var result []DepositMethods
err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenDepositMethods, params, &result)
if err != nil {
return response.Result, err
return nil, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetTradeBalance returns full information about your trades on Kraken
func (k *Kraken) GetTradeBalance(ctx context.Context, args ...TradeBalanceOptions) (TradeBalanceInfo, error) {
func (k *Kraken) GetTradeBalance(ctx context.Context, args ...TradeBalanceOptions) (*TradeBalanceInfo, error) {
params := url.Values{}
if args != nil {
@@ -581,20 +479,16 @@ func (k *Kraken) GetTradeBalance(ctx context.Context, args ...TradeBalanceOption
}
}
var response struct {
Error []string `json:"error"`
Result TradeBalanceInfo `json:"result"`
var result TradeBalanceInfo
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeBalance, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeBalance, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// GetOpenOrders returns all current open orders
func (k *Kraken) GetOpenOrders(ctx context.Context, args OrderInfoOptions) (OpenOrders, error) {
func (k *Kraken) GetOpenOrders(ctx context.Context, args OrderInfoOptions) (*OpenOrders, error) {
params := url.Values{}
if args.Trades {
@@ -605,20 +499,16 @@ func (k *Kraken) GetOpenOrders(ctx context.Context, args OrderInfoOptions) (Open
params.Set("userref", strconv.FormatInt(int64(args.UserRef), 10))
}
var response struct {
Error []string `json:"error"`
Result OpenOrders `json:"result"`
var result OpenOrders
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOpenOrders, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOpenOrders, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// GetClosedOrders returns a list of closed orders
func (k *Kraken) GetClosedOrders(ctx context.Context, args GetClosedOrdersOptions) (ClosedOrders, error) {
func (k *Kraken) GetClosedOrders(ctx context.Context, args GetClosedOrdersOptions) (*ClosedOrders, error) {
params := url.Values{}
if args.Trades {
@@ -645,16 +535,12 @@ func (k *Kraken) GetClosedOrders(ctx context.Context, args GetClosedOrdersOption
params.Set("closetime", args.CloseTime)
}
var response struct {
Error []string `json:"error"`
Result ClosedOrders `json:"result"`
var result ClosedOrders
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenClosedOrders, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenClosedOrders, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// QueryOrdersInfo returns order information
@@ -675,20 +561,16 @@ func (k *Kraken) QueryOrdersInfo(ctx context.Context, args OrderInfoOptions, txi
params.Set("userref", strconv.FormatInt(int64(args.UserRef), 10))
}
var response struct {
Error []string `json:"error"`
Result map[string]OrderInfo `json:"result"`
var result map[string]OrderInfo
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryOrders, params, &result); err != nil {
return result, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryOrders, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetTradesHistory returns trade history information
func (k *Kraken) GetTradesHistory(ctx context.Context, args ...GetTradesHistoryOptions) (TradesHistory, error) {
func (k *Kraken) GetTradesHistory(ctx context.Context, args ...GetTradesHistoryOptions) (*TradesHistory, error) {
params := url.Values{}
if args != nil {
@@ -713,16 +595,12 @@ func (k *Kraken) GetTradesHistory(ctx context.Context, args ...GetTradesHistoryO
}
}
var response struct {
Error []string `json:"error"`
Result TradesHistory `json:"result"`
var result TradesHistory
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeHistory, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeHistory, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// QueryTrades returns information on a specific trade
@@ -739,16 +617,12 @@ func (k *Kraken) QueryTrades(ctx context.Context, trades bool, txid string, txid
params.Set("txid", txid+","+strings.Join(txids, ","))
}
var response struct {
Error []string `json:"error"`
Result map[string]TradeInfo `json:"result"`
var result map[string]TradeInfo
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryTrades, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryTrades, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// OpenPositions returns current open positions
@@ -763,20 +637,16 @@ func (k *Kraken) OpenPositions(ctx context.Context, docalcs bool, txids ...strin
params.Set("docalcs", "true")
}
var response struct {
Error []string `json:"error"`
Result map[string]Position `json:"result"`
var result map[string]Position
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOpenPositions, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOpenPositions, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetLedgers returns current ledgers
func (k *Kraken) GetLedgers(ctx context.Context, args ...GetLedgersOptions) (Ledgers, error) {
func (k *Kraken) GetLedgers(ctx context.Context, args ...GetLedgersOptions) (*Ledgers, error) {
params := url.Values{}
if args != nil {
@@ -805,16 +675,12 @@ func (k *Kraken) GetLedgers(ctx context.Context, args ...GetLedgersOptions) (Led
}
}
var response struct {
Error []string `json:"error"`
Result Ledgers `json:"result"`
var result Ledgers
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenLedgers, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenLedgers, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// QueryLedgers queries an individual ledger by ID
@@ -827,24 +693,16 @@ func (k *Kraken) QueryLedgers(ctx context.Context, id string, ids ...string) (ma
params.Set("id", id+","+strings.Join(ids, ","))
}
var response struct {
Error []string `json:"error"`
Result map[string]LedgerInfo `json:"result"`
var result map[string]LedgerInfo
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryLedgers, params, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenQueryLedgers, params, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetTradeVolume returns your trade volume by currency
func (k *Kraken) GetTradeVolume(ctx context.Context, feeinfo bool, symbol ...currency.Pair) (*TradeVolumeResponse, error) {
var response struct {
Error []string `json:"error"`
Result *TradeVolumeResponse `json:"result"`
}
params := url.Values{}
formattedPairs := make([]string, len(symbol))
for x := range symbol {
@@ -862,22 +720,19 @@ func (k *Kraken) GetTradeVolume(ctx context.Context, feeinfo bool, symbol ...cur
params.Set("fee-info", "true")
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeVolume, params, &response); err != nil {
var result *TradeVolumeResponse
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenTradeVolume, params, &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// AddOrder adds a new order for Kraken exchange
func (k *Kraken) AddOrder(ctx context.Context, symbol currency.Pair, side, orderType string, volume, price, price2, leverage float64, args *AddOrderOptions) (AddOrderResponse, error) {
var response struct {
Error []string `json:"error"`
Result AddOrderResponse `json:"result"`
}
func (k *Kraken) AddOrder(ctx context.Context, symbol currency.Pair, side, orderType string, volume, price, price2, leverage float64, args *AddOrderOptions) (*AddOrderResponse, error) {
symbolValue, err := k.FormatSymbol(symbol, asset.Spot)
if err != nil {
return response.Result, err
return nil, err
}
params := url.Values{
"pair": {symbolValue},
@@ -930,49 +785,26 @@ func (k *Kraken) AddOrder(ctx context.Context, symbol currency.Pair, side, order
params.Set("timeinforce", string(args.TimeInForce))
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOrderPlace, params, &response); err != nil {
return response.Result, err
var result AddOrderResponse
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOrderPlace, params, &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return &result, nil
}
// CancelExistingOrder cancels order by orderID
func (k *Kraken) CancelExistingOrder(ctx context.Context, txid string) (CancelOrderResponse, error) {
func (k *Kraken) CancelExistingOrder(ctx context.Context, txid string) (*CancelOrderResponse, error) {
values := url.Values{
"txid": {txid},
}
var response struct {
Error []string `json:"error"`
Result CancelOrderResponse `json:"result"`
var result CancelOrderResponse
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOrderCancel, values, &result); err != nil {
return nil, err
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenOrderCancel, values, &response); err != nil {
return response.Result, err
}
return response.Result, GetError(response.Error)
}
// GetError parse Exchange errors in response and return the first one.
//
// Error format from API doc:
// - error = array of error messages in the format of:
// <char-severity code><string-error category>:<string-error type>[:<string-extra info>]
// severity code can be E for error or W for warning
func GetError(apiErrors []string) error {
const exchangeName = "Kraken"
for _, e := range apiErrors {
switch e[0] {
case 'W':
log.Warnf(log.ExchangeSys, "%s API warning: %v\n", exchangeName, e[1:])
default:
return fmt.Errorf("%s API error: %v", exchangeName, e[1:])
}
}
return nil
return &result, nil
}
// SendHTTPRequest sends an unauthenticated HTTP requests
@@ -982,18 +814,50 @@ func (k *Kraken) SendHTTPRequest(ctx context.Context, ep exchange.URL, path stri
return err
}
var rawMessage json.RawMessage
item := &request.Item{
Method: http.MethodGet,
Path: endpoint + path,
Result: result,
Result: &rawMessage,
Verbose: k.Verbose,
HTTPDebugging: k.HTTPDebugging,
HTTPRecording: k.HTTPRecording,
}
return k.SendPayload(ctx, request.Unset, func() (*request.Item, error) {
err = k.SendPayload(ctx, request.Unset, func() (*request.Item, error) {
return item, nil
}, request.UnauthenticatedRequest)
if err != nil {
return err
}
isSpot := ep == exchange.RestSpot
if isSpot {
genResponse := genericRESTResponse{
Result: result,
}
if err := json.Unmarshal(rawMessage, &genResponse); err != nil {
return err
}
if genResponse.Error.Warnings() != "" {
log.Warnf(log.ExchangeSys, "%v: REST request warning: %v", k.Name, genResponse.Error.Warnings())
}
return genResponse.Error.Errors()
}
var genResp genericFuturesResponse
if err := json.Unmarshal(rawMessage, &genResp); err != nil {
return err
}
if genResp.Error != "" && genResp.Result != "success" {
return errors.New(genResp.Error)
}
return json.Unmarshal(rawMessage, result)
}
// SendAuthenticatedHTTPRequest sends an authenticated HTTP request
@@ -1048,23 +912,23 @@ func (k *Kraken) SendAuthenticatedHTTPRequest(ctx context.Context, ep exchange.U
if err != nil {
return err
}
var errCap SpotAuthError
if err = json.Unmarshal(interim, &errCap); err == nil && errCap.Error != nil {
switch e := errCap.Error.(type) {
case []string:
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, e[0])
case []interface{}: // no error will be an empty []interface{}
if len(e) > 0 {
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, e)
}
default:
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, e)
}
genResponse := genericRESTResponse{
Result: result,
}
err = json.Unmarshal(interim, result)
if err != nil {
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, err)
if err := json.Unmarshal(interim, &genResponse); err != nil {
return fmt.Errorf("%w %w", request.ErrAuthRequestFailed, err)
}
if err := genResponse.Error.Errors(); err != nil {
return fmt.Errorf("%w %w", request.ErrAuthRequestFailed, err)
}
if genResponse.Error.Warnings() != "" {
log.Warnf(log.ExchangeSys, "%v: AUTH REST request warning: %v", k.Name, genResponse.Error.Warnings())
}
return nil
}
@@ -1139,66 +1003,54 @@ func calculateTradingFee(currency string, feePair map[string]TradeVolumeFee, pur
// GetCryptoDepositAddress returns a deposit address for a cryptocurrency
func (k *Kraken) GetCryptoDepositAddress(ctx context.Context, method, code string, createNew bool) ([]DepositAddress, error) {
var resp = struct {
Error []string `json:"error"`
Result []DepositAddress `json:"result"`
}{}
values := url.Values{}
values.Set("asset", code)
values.Set("method", method)
if createNew {
values.Set("new", "1")
values.Set("new", "true")
}
err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenDepositAddresses, values, &resp)
var result []DepositAddress
err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenDepositAddresses, values, &result)
if err != nil {
return nil, err
}
if len(resp.Result) == 0 {
if len(result) == 0 {
return nil, errors.New("no addresses returned")
}
return resp.Result, nil
return result, nil
}
// WithdrawStatus gets the status of recent withdrawals
func (k *Kraken) WithdrawStatus(ctx context.Context, c currency.Code, method string) ([]WithdrawStatusResponse, error) {
var response struct {
Error []string `json:"error"`
Result []WithdrawStatusResponse `json:"result"`
}
params := url.Values{}
params.Set("asset", c.String())
if method != "" {
params.Set("method", method)
}
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawStatus, params, &response); err != nil {
return response.Result, err
var result []WithdrawStatusResponse
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawStatus, params, &result); err != nil {
return nil, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// WithdrawCancel sends a withdrawal cancellation request
func (k *Kraken) WithdrawCancel(ctx context.Context, c currency.Code, refID string) (bool, error) {
var response struct {
Error []string `json:"error"`
Result bool `json:"result"`
}
params := url.Values{}
params.Set("asset", c.String())
params.Set("refid", refID)
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawCancel, params, &response); err != nil {
return response.Result, err
var result bool
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWithdrawCancel, params, &result); err != nil {
return result, err
}
return response.Result, GetError(response.Error)
return result, nil
}
// GetWebsocketToken returns a websocket token
@@ -1207,10 +1059,7 @@ func (k *Kraken) GetWebsocketToken(ctx context.Context) (string, error) {
if err := k.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, krakenWebsocketToken, url.Values{}, &response); err != nil {
return "", err
}
if len(response.Error) > 0 {
return "", fmt.Errorf("%s - %v", k.Name, response.Error)
}
return response.Result.Token, nil
return response.Token, nil
}
// LookupAltName converts a currency into its altName (ZUSD -> USD)

20
exchanges/kraken/kraken_futures.go
View File

@@ -377,20 +377,20 @@ func (k *Kraken) SendFuturesAuthRequest(ctx context.Context, method, path string
}, nil
}
err = k.SendPayload(ctx, request.Unset, newRequest, request.AuthenticatedRequest)
if err != nil {
if err := k.SendPayload(ctx, request.Unset, newRequest, request.AuthenticatedRequest); err != nil {
return err
}
var errCap AuthErrorData
if err = json.Unmarshal(interim, &errCap); err == nil {
if errCap.Result != "success" && errCap.Error != "" {
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, errCap.Error)
}
var resp genericFuturesResponse
if err := json.Unmarshal(interim, &resp); err != nil {
return fmt.Errorf("%w %w", request.ErrAuthRequestFailed, err)
} else if resp.Error != "" && resp.Result != "success" {
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, resp.Error)
}
err = json.Unmarshal(interim, result)
if err != nil {
return fmt.Errorf("%w %v", request.ErrAuthRequestFailed, err)
if err := json.Unmarshal(interim, result); err != nil {
return fmt.Errorf("%w %w", request.ErrAuthRequestFailed, err)
}
return nil
}

76
exchanges/kraken/kraken_test.go
View File

@@ -2320,3 +2320,79 @@ func TestGetCurrencyTradeURL(t *testing.T) {
assert.NotEmpty(t, resp)
}
}
func TestErrorResponse(t *testing.T) {
var g genericRESTResponse
tests := []struct {
name string
jsonStr string
expectError bool
errorMsg string
warningMsg string
requiresReset bool
}{
{
name: "No errors or warnings",
jsonStr: `{"error":[],"result":{"unixtime":1721884425,"rfc1123":"Thu, 25 Jul 24 05:13:45 +0000"}}`,
},
{
name: "Invalid error type int",
jsonStr: `{"error":[69420],"result":{}}`,
expectError: true,
errorMsg: "unable to convert 69420 to string",
},
{
name: "Unhandled error type float64",
jsonStr: `{"error":124,"result":{}}`,
expectError: true,
errorMsg: "unhandled error response type float64",
},
{
name: "Known error string",
jsonStr: `{"error":["EQuery:Unknown asset pair"],"result":{}}`,
errorMsg: "EQuery:Unknown asset pair",
},
{
name: "Known error string (single)",
jsonStr: `{"error":"EService:Unavailable","result":{}}`,
errorMsg: "EService:Unavailable",
},
{
name: "Warning string in array",
jsonStr: `{"error":["WGeneral:Danger"],"result":{}}`,
warningMsg: "WGeneral:Danger",
requiresReset: true,
},
{
name: "Warning string",
jsonStr: `{"error":"WGeneral:Unknown warning","result":{}}`,
warningMsg: "WGeneral:Unknown warning",
requiresReset: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.requiresReset {
g = genericRESTResponse{}
}
err := json.Unmarshal([]byte(tt.jsonStr), &g)
if tt.expectError {
require.ErrorContains(t, err, tt.errorMsg, "Unmarshal should error")
} else {
require.NoError(t, err)
if tt.errorMsg != "" {
assert.ErrorContains(t, g.Error.Errors(), tt.errorMsg, "Errors should contain %s", tt.errorMsg)
} else {
assert.NoError(t, g.Error.Errors(), "Errors should not error")
}
if tt.warningMsg != "" {
assert.Contains(t, g.Error.Warnings(), tt.warningMsg, "Warnings should contain %s", tt.warningMsg)
} else {
assert.Empty(t, g.Error.Warnings(), "Warnings should be empty")
}
}
})
}
}

91
exchanges/kraken/kraken_types.go
View File

@@ -1,8 +1,13 @@
package kraken
import (
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/currency"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/subscription"
@@ -84,16 +89,10 @@ type GenericResponse struct {
Result string `json:"result"`
}
// AuthErrorData stores authenticated error messages
type AuthErrorData struct {
Result string `json:"result"`
ServerTime string `json:"serverTime"`
Error string `json:"error"`
}
// SpotAuthError stores authenticated error messages
type SpotAuthError struct {
Error interface{} `json:"error"` // can be a []string or string
type genericFuturesResponse struct {
Result string `json:"result"`
ServerTime time.Time `json:"serverTime"`
Error string `json:"error"`
}
// Asset holds asset information
@@ -161,7 +160,7 @@ type TickerResponse struct {
// OpenHighLowClose contains ticker event information
type OpenHighLowClose struct {
Time float64
Time time.Time
Open float64
High float64
Low float64
@@ -171,13 +170,6 @@ type OpenHighLowClose struct {
Count float64
}
// RecentTradesResponse defines the response for recent trades
type RecentTradesResponse struct {
Error []interface{} `json:"error"`
Result map[string]interface{} `json:"result"`
Last string `json:"last"`
}
// RecentTrades holds recent trade data
type RecentTrades struct {
Price float64
@@ -191,8 +183,9 @@ type RecentTrades struct {
// OrderbookBase stores the orderbook price and amount data
type OrderbookBase struct {
Price float64
Amount float64
Price types.Number
Amount types.Number
Timestamp time.Time
}
// Orderbook stores the bids and asks orderbook data
@@ -570,11 +563,8 @@ type WebsocketChannelData struct {
// WsTokenResponse holds the WS auth token
type WsTokenResponse struct {
Error []string `json:"error"`
Result struct {
Expires int64 `json:"expires"`
Token string `json:"token"`
} `json:"result"`
Expires int64 `json:"expires"`
Token string `json:"token"`
}
type wsSystemStatus struct {
@@ -743,3 +733,54 @@ var (
// RequestParamsTimeIOC IOC
RequestParamsTimeIOC = RequestParamsTimeForceType("IOC")
)
type genericRESTResponse struct {
Error errorResponse `json:"error"`
Result any `json:"result"`
}
type errorResponse struct {
warnings []string
errors error
}
func (e *errorResponse) UnmarshalJSON(data []byte) error {
var errInterface any
if err := json.Unmarshal(data, &errInterface); err != nil {
return err
}
switch d := errInterface.(type) {
case string:
if d[0] == 'E' {
e.errors = common.AppendError(e.errors, errors.New(d))
} else {
e.warnings = append(e.warnings, d)
}
case []interface{}:
for x := range d {
errStr, ok := d[x].(string)
if !ok {
return fmt.Errorf("unable to convert %v to string", d[x])
}
if errStr[0] == 'E' {
e.errors = common.AppendError(e.errors, errors.New(errStr))
} else {
e.warnings = append(e.warnings, errStr)
}
}
default:
return fmt.Errorf("unhandled error response type %T", errInterface)
}
return nil
}
// Errors returns one or many errors as an error
func (e errorResponse) Errors() error {
return e.errors
}
// Warnings returns a string of warnings
func (e errorResponse) Warnings() string {
return strings.Join(e.warnings, ", ")
}

18
exchanges/kraken/kraken_wrapper.go
View File

@@ -500,15 +500,15 @@ func (k *Kraken) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType
book.Bids = make([]orderbook.Tranche, len(orderbookNew.Bids))
for x := range orderbookNew.Bids {
book.Bids[x] = orderbook.Tranche{
Amount: orderbookNew.Bids[x].Amount,
Price: orderbookNew.Bids[x].Price,
Amount: orderbookNew.Bids[x].Amount.Float64(),
Price: orderbookNew.Bids[x].Price.Float64(),
}
}
book.Asks = make([]orderbook.Tranche, len(orderbookNew.Asks))
for y := range orderbookNew.Asks {
book.Asks[y] = orderbook.Tranche{
Amount: orderbookNew.Asks[y].Amount,
Price: orderbookNew.Asks[y].Price,
Amount: orderbookNew.Asks[y].Amount.Float64(),
Price: orderbookNew.Asks[y].Price.Float64(),
}
}
case asset.Futures:
@@ -742,7 +742,7 @@ func (k *Kraken) SubmitOrder(ctx context.Context, s *order.Submit) (*order.Submi
return nil, err
}
} else {
var response AddOrderResponse
var response *AddOrderResponse
response, err = k.AddOrder(ctx,
s.Pair,
s.Side.String(),
@@ -1507,15 +1507,11 @@ func (k *Kraken) GetHistoricCandles(ctx context.Context, pair currency.Pair, a a
}
for x := range candles {
timeValue, err := convert.TimeFromUnixTimestampFloat(candles[x].Time * 1000)
if err != nil {
return nil, err
}
if timeValue.Before(req.Start) || timeValue.After(req.End) {
if candles[x].Time.Before(req.Start) || candles[x].Time.After(req.End) {
continue
}
timeSeries = append(timeSeries, kline.Candle{
Time: timeValue,
Time: candles[x].Time,
Open: candles[x].Open,
High: candles[x].High,
Low: candles[x].Low,