-
Notifications
You must be signed in to change notification settings - Fork 1
/
balances.go
121 lines (96 loc) · 2.77 KB
/
balances.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package main
import (
"context"
"fmt"
"time"
"github.com/adshao/go-binance/v2"
influxdb "github.com/influxdata/influxdb-client-go/v2"
influxapi "github.com/influxdata/influxdb-client-go/v2/api"
"github.com/tideland/golib/logger"
)
type BalanceHandler struct {
client *binance.Client
currency string
balances []binance.Balance
}
func NewBalanceHandler(client *binance.Client, currency string) (*BalanceHandler, error) {
b := &BalanceHandler{client: client, currency: currency, balances: make([]binance.Balance, 0)}
err := b.loadAcountBalances()
if err != nil {
return nil, err
}
return b, nil
}
func (b *BalanceHandler) LogAccountBalances(p *PriceHandler) {
logger.Infof("Balances:")
if len(b.balances) == 0 {
logger.Infof("No balances found")
return
}
total := 0.0
for _, bal := range b.balances {
price := p.PriceForSymbol(bal.Asset)
freeValue := toFloat(bal.Free) * price
lockedValue := toFloat(bal.Locked) * price
total += freeValue + lockedValue
logger.Infof(
"%s: free: %s, locked: %s, free_value: %s %.2f, locked_value: %s %.2f",
bal.Asset,
bal.Free,
bal.Locked,
b.currency,
freeValue,
b.currency,
lockedValue,
)
}
logger.Infof("Total Balance: %.2f", total)
}
func (b *BalanceHandler) SymbolsFromBalances() []string {
symbols := make([]string, len(b.balances))
for ii, bal := range b.balances {
symbols[ii] = bal.Asset
}
return symbols
}
func (b *BalanceHandler) SendBalancesToInflux(writeAPI influxapi.WriteAPI, p *PriceHandler) {
logger.Infof("Start sending balances to influxdb")
for _, bal := range b.balances {
price := p.PriceForSymbol(bal.Asset)
p := influxdb.NewPoint(
"balances",
map[string]string{"symbol": bal.Asset},
map[string]interface{}{"current": toFloat(bal.Free) * price},
time.Now(),
)
writeAPI.WritePoint(p)
}
logger.Infof("Finished sending balances to influxdb")
}
func (b *BalanceHandler) SendBalancesToPrometheus(p *PriceHandler) {
logger.Infof("Generating prometheus metrics for balances")
for _, bal := range b.balances {
price := p.PriceForSymbol(bal.Asset)
balanceMetric.WithLabelValues(bal.Asset, "free").Set(toFloat(bal.Free) * price)
balanceMetric.WithLabelValues(bal.Asset, "locked").Set(toFloat(bal.Locked) * price)
}
}
func (b *BalanceHandler) loadAcountBalances() error {
logger.Infof("Retrieving account info")
info, err := b.client.NewGetAccountService().Do(context.Background())
if err != nil {
return err
}
for _, bal := range info.Balances {
if !isZero(bal.Free) || !isZero(bal.Locked) {
if bal.Asset != b.currency {
bal.Asset = fmt.Sprintf("%s%s", bal.Asset, b.currency)
}
b.balances = append(b.balances, bal)
}
}
return nil
}
func isZero(balanceString string) bool {
return balanceString == "0.00000000" || balanceString == "0.00"
}