forked from stellar/go
-
Notifications
You must be signed in to change notification settings - Fork 0
/
trustline.go
127 lines (106 loc) · 3.1 KB
/
trustline.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
122
123
124
125
126
127
package core
import (
"errors"
sq "github.com/Masterminds/squirrel"
"github.com/stellar/go/xdr"
)
func (tl Trustline) IsAuthorized() bool {
return (tl.Flags & int32(xdr.TrustLineFlagsAuthorizedFlag)) != 0
}
func (tl Trustline) IsAuthorizedToMaintainLiabilities() bool {
return (tl.Flags & int32(xdr.TrustLineFlagsAuthorizedToMaintainLiabilitiesFlag)) != 0
}
// AssetsForAddress returns a list of assets and balances for those assets held by
// a given address.
func (q *Q) AssetsForAddress(addy string) ([]xdr.Asset, []xdr.Int64, error) {
var tls []Trustline
var account Account
if err := q.AccountByAddress(&account, addy); q.NoRows(err) {
// if there is no account for the given address then
// we return an empty list of assets and balances
return []xdr.Asset{}, []xdr.Int64{}, nil
} else if err != nil {
return nil, nil, err
}
if err := q.TrustlinesByAddress(&tls, addy); err != nil {
return nil, nil, err
}
assets := make([]xdr.Asset, len(tls)+1)
balances := make([]xdr.Int64, len(tls)+1)
var err error
for i, tl := range tls {
assets[i], err = AssetFromDB(tl.Assettype, tl.Assetcode, tl.Issuer)
if err != nil {
return nil, nil, err
}
balances[i] = tl.Balance
}
assets[len(assets)-1], err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
balances[len(assets)-1] = account.Balance
return assets, balances, err
}
// AllAssets loads all (unique) assets from core DB
func (q *Q) AllAssets(dest interface{}) error {
var tls []Trustline
sql := sq.Select(
"tl.assettype",
"tl.issuer",
"tl.assetcode",
).From("trustlines tl").GroupBy("(tl.assettype, tl.issuer, tl.assetcode)")
err := q.Select(&tls, sql)
if err != nil {
return err
}
dtl, ok := dest.(*[]xdr.Asset)
if !ok {
return errors.New("Invalid destination")
}
result := make([]xdr.Asset, len(tls))
*dtl = result
for i, tl := range tls {
result[i], err = AssetFromDB(tl.Assettype, tl.Assetcode, tl.Issuer)
if err != nil {
return err
}
}
return nil
}
// TrustlinesByAddress loads all trustlines for `addy`
func (q *Q) TrustlinesByAddress(dest interface{}, addy string) error {
sql := selectTrustline.Where("accountid = ?", addy)
return q.Select(dest, sql)
}
// BalancesForAsset returns all the balances by asset type, code, issuer
func (q *Q) BalancesForAsset(
assetType int32,
assetCode string,
assetIssuer string,
) (int32, string, error) {
sql := selectBalances.Where(sq.Eq{
"assettype": assetType,
"assetcode": assetCode,
"issuer": assetIssuer,
"flags": 1,
})
result := struct {
Count int32 `db:"count"`
Sum string `db:"sum"`
}{}
err := q.Get(&result, sql)
return result.Count, result.Sum, err
}
var selectTrustline = sq.Select(
"tl.accountid",
"tl.assettype",
"tl.issuer",
"tl.assetcode",
"tl.tlimit",
"tl.balance",
"tl.flags",
"tl.lastmodified",
// Liabilities can be NULL so can error without `coalesce`:
// `Invalid value for xdr.Int64`
"coalesce(tl.buyingliabilities, 0) as buyingliabilities",
"coalesce(tl.sellingliabilities, 0) as sellingliabilities",
).From("trustlines tl")
var selectBalances = sq.Select("COUNT(*)", "COALESCE(SUM(balance), 0) as sum").From("trustlines")