/
keeper.go
366 lines (327 loc) · 12.8 KB
/
keeper.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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
package keeper
import (
"time"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/store/prefix"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/elysium-station/black/x/hard/types"
)
// Keeper keeper for the hard module
type Keeper struct {
key storetypes.StoreKey
cdc codec.Codec
paramSubspace paramtypes.Subspace
accountKeeper types.AccountKeeper
bankKeeper types.BankKeeper
pricefeedKeeper types.PricefeedKeeper
auctionKeeper types.AuctionKeeper
hooks types.HARDHooks
}
// NewKeeper creates a new keeper
func NewKeeper(cdc codec.Codec, key storetypes.StoreKey, paramstore paramtypes.Subspace,
ak types.AccountKeeper, bk types.BankKeeper,
pfk types.PricefeedKeeper, auk types.AuctionKeeper,
) Keeper {
if !paramstore.HasKeyTable() {
paramstore = paramstore.WithKeyTable(types.ParamKeyTable())
}
return Keeper{
key: key,
cdc: cdc,
paramSubspace: paramstore,
accountKeeper: ak,
bankKeeper: bk,
pricefeedKeeper: pfk,
auctionKeeper: auk,
hooks: nil,
}
}
// SetHooks adds hooks to the keeper.
func (k *Keeper) SetHooks(hooks types.HARDHooks) *Keeper {
if k.hooks != nil {
panic("cannot set hard hooks twice")
}
k.hooks = hooks
return k
}
// GetDeposit returns a deposit from the store for a particular depositor address, deposit denom
func (k Keeper) GetDeposit(ctx sdk.Context, depositor sdk.AccAddress) (types.Deposit, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.DepositsKeyPrefix)
bz := store.Get(depositor.Bytes())
if len(bz) == 0 {
return types.Deposit{}, false
}
var deposit types.Deposit
k.cdc.MustUnmarshal(bz, &deposit)
return deposit, true
}
// SetDeposit sets the input deposit in the store, prefixed by the deposit type, deposit denom, and depositor address, in that order
func (k Keeper) SetDeposit(ctx sdk.Context, deposit types.Deposit) {
store := prefix.NewStore(ctx.KVStore(k.key), types.DepositsKeyPrefix)
bz := k.cdc.MustMarshal(&deposit)
store.Set(deposit.Depositor.Bytes(), bz)
}
// DeleteDeposit deletes a deposit from the store
func (k Keeper) DeleteDeposit(ctx sdk.Context, deposit types.Deposit) {
store := prefix.NewStore(ctx.KVStore(k.key), types.DepositsKeyPrefix)
store.Delete(deposit.Depositor.Bytes())
}
// IterateDeposits iterates over all deposit objects in the store and performs a callback function
func (k Keeper) IterateDeposits(ctx sdk.Context, cb func(deposit types.Deposit) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.key), types.DepositsKeyPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var deposit types.Deposit
k.cdc.MustUnmarshal(iterator.Value(), &deposit)
if cb(deposit) {
break
}
}
}
// GetDepositsByUser gets all deposits for an individual user
func (k Keeper) GetDepositsByUser(ctx sdk.Context, user sdk.AccAddress) []types.Deposit {
var deposits []types.Deposit
k.IterateDeposits(ctx, func(deposit types.Deposit) (stop bool) {
if deposit.Depositor.Equals(user) {
deposits = append(deposits, deposit)
}
return false
})
return deposits
}
// GetBorrow returns a Borrow from the store for a particular borrower address and borrow denom
func (k Keeper) GetBorrow(ctx sdk.Context, borrower sdk.AccAddress) (types.Borrow, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowsKeyPrefix)
bz := store.Get(borrower)
if len(bz) == 0 {
return types.Borrow{}, false
}
var borrow types.Borrow
k.cdc.MustUnmarshal(bz, &borrow)
return borrow, true
}
// SetBorrow sets the input borrow in the store, prefixed by the borrower address and borrow denom
func (k Keeper) SetBorrow(ctx sdk.Context, borrow types.Borrow) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowsKeyPrefix)
bz := k.cdc.MustMarshal(&borrow)
store.Set(borrow.Borrower, bz)
}
// DeleteBorrow deletes a borrow from the store
func (k Keeper) DeleteBorrow(ctx sdk.Context, borrow types.Borrow) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowsKeyPrefix)
store.Delete(borrow.Borrower)
}
// IterateBorrows iterates over all borrow objects in the store and performs a callback function
func (k Keeper) IterateBorrows(ctx sdk.Context, cb func(borrow types.Borrow) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowsKeyPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var borrow types.Borrow
k.cdc.MustUnmarshal(iterator.Value(), &borrow)
if cb(borrow) {
break
}
}
}
// SetBorrowedCoins sets the total amount of coins currently borrowed in the store
func (k Keeper) SetBorrowedCoins(ctx sdk.Context, borrowedCoins sdk.Coins) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowedCoinsPrefix)
if borrowedCoins.Empty() {
store.Set(types.BorrowedCoinsPrefix, []byte{})
} else {
bz := k.cdc.MustMarshal(&types.CoinsProto{
Coins: borrowedCoins,
})
store.Set(types.BorrowedCoinsPrefix, bz)
}
}
// GetBorrowedCoins returns an sdk.Coins object from the store representing all currently borrowed coins
func (k Keeper) GetBorrowedCoins(ctx sdk.Context) (sdk.Coins, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowedCoinsPrefix)
bz := store.Get(types.BorrowedCoinsPrefix)
if len(bz) == 0 {
return sdk.Coins{}, false
}
var borrowed types.CoinsProto
k.cdc.MustUnmarshal(bz, &borrowed)
return borrowed.Coins, true
}
// SetSuppliedCoins sets the total amount of coins currently supplied in the store
func (k Keeper) SetSuppliedCoins(ctx sdk.Context, suppliedCoins sdk.Coins) {
store := prefix.NewStore(ctx.KVStore(k.key), types.SuppliedCoinsPrefix)
if suppliedCoins.Empty() {
store.Set(types.SuppliedCoinsPrefix, []byte{})
} else {
bz := k.cdc.MustMarshal(&types.CoinsProto{
Coins: suppliedCoins,
})
store.Set(types.SuppliedCoinsPrefix, bz)
}
}
// GetSuppliedCoins returns an sdk.Coins object from the store representing all currently supplied coins
func (k Keeper) GetSuppliedCoins(ctx sdk.Context) (sdk.Coins, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.SuppliedCoinsPrefix)
bz := store.Get(types.SuppliedCoinsPrefix)
if len(bz) == 0 {
return sdk.Coins{}, false
}
var supplied types.CoinsProto
k.cdc.MustUnmarshal(bz, &supplied)
return supplied.Coins, true
}
// GetMoneyMarket returns a money market from the store for a denom
func (k Keeper) GetMoneyMarket(ctx sdk.Context, denom string) (types.MoneyMarket, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.MoneyMarketsPrefix)
bz := store.Get([]byte(denom))
if len(bz) == 0 {
return types.MoneyMarket{}, false
}
var moneyMarket types.MoneyMarket
k.cdc.MustUnmarshal(bz, &moneyMarket)
return moneyMarket, true
}
// SetMoneyMarket sets a money market in the store for a denom
func (k Keeper) SetMoneyMarket(ctx sdk.Context, denom string, moneyMarket types.MoneyMarket) {
store := prefix.NewStore(ctx.KVStore(k.key), types.MoneyMarketsPrefix)
bz := k.cdc.MustMarshal(&moneyMarket)
store.Set([]byte(denom), bz)
}
// DeleteMoneyMarket deletes a money market from the store
func (k Keeper) DeleteMoneyMarket(ctx sdk.Context, denom string) {
store := prefix.NewStore(ctx.KVStore(k.key), types.MoneyMarketsPrefix)
store.Delete([]byte(denom))
}
// IterateMoneyMarkets iterates over all money markets objects in the store and performs a callback function
//
// that returns both the money market and the key (denom) it's stored under
func (k Keeper) IterateMoneyMarkets(ctx sdk.Context, cb func(denom string, moneyMarket types.MoneyMarket) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.key), types.MoneyMarketsPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var moneyMarket types.MoneyMarket
k.cdc.MustUnmarshal(iterator.Value(), &moneyMarket)
if cb(string(iterator.Key()), moneyMarket) {
break
}
}
}
// GetAllMoneyMarkets returns all money markets from the store
func (k Keeper) GetAllMoneyMarkets(ctx sdk.Context) (moneyMarkets types.MoneyMarkets) {
k.IterateMoneyMarkets(ctx, func(denom string, moneyMarket types.MoneyMarket) bool {
moneyMarkets = append(moneyMarkets, moneyMarket)
return false
})
return
}
// GetPreviousAccrualTime returns the last time an individual market accrued interest
func (k Keeper) GetPreviousAccrualTime(ctx sdk.Context, denom string) (time.Time, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.PreviousAccrualTimePrefix)
bz := store.Get([]byte(denom))
if len(bz) == 0 {
return time.Time{}, false
}
var previousAccrualTime time.Time
if err := previousAccrualTime.UnmarshalBinary(bz); err != nil {
panic(err)
}
return previousAccrualTime, true
}
// SetPreviousAccrualTime sets the most recent accrual time for a particular market
func (k Keeper) SetPreviousAccrualTime(ctx sdk.Context, denom string, previousAccrualTime time.Time) {
store := prefix.NewStore(ctx.KVStore(k.key), types.PreviousAccrualTimePrefix)
bz, err := previousAccrualTime.MarshalBinary()
if err != nil {
panic(err)
}
store.Set([]byte(denom), bz)
}
// SetTotalReserves sets the total reserves for an individual market
func (k Keeper) SetTotalReserves(ctx sdk.Context, coins sdk.Coins) {
store := prefix.NewStore(ctx.KVStore(k.key), types.TotalReservesPrefix)
if coins.Empty() {
store.Set(types.TotalReservesPrefix, []byte{})
return
}
bz := k.cdc.MustMarshal(&types.CoinsProto{
Coins: coins,
})
store.Set(types.TotalReservesPrefix, bz)
}
// GetTotalReserves returns the total reserves for an individual market
func (k Keeper) GetTotalReserves(ctx sdk.Context) (sdk.Coins, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.TotalReservesPrefix)
bz := store.Get(types.TotalReservesPrefix)
if len(bz) == 0 {
return sdk.Coins{}, false
}
var totalReserves types.CoinsProto
k.cdc.MustUnmarshal(bz, &totalReserves)
return totalReserves.Coins, true
}
// GetBorrowInterestFactor returns the current borrow interest factor for an individual market
func (k Keeper) GetBorrowInterestFactor(ctx sdk.Context, denom string) (sdk.Dec, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowInterestFactorPrefix)
bz := store.Get([]byte(denom))
if len(bz) == 0 {
return sdk.ZeroDec(), false
}
var borrowInterestFactor sdk.DecProto
k.cdc.MustUnmarshal(bz, &borrowInterestFactor)
return borrowInterestFactor.Dec, true
}
// SetBorrowInterestFactor sets the current borrow interest factor for an individual market
func (k Keeper) SetBorrowInterestFactor(ctx sdk.Context, denom string, borrowInterestFactor sdk.Dec) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowInterestFactorPrefix)
bz := k.cdc.MustMarshal(&sdk.DecProto{Dec: borrowInterestFactor})
store.Set([]byte(denom), bz)
}
// IterateBorrowInterestFactors iterates over all borrow interest factors in the store and returns
// both the borrow interest factor and the key (denom) it's stored under
func (k Keeper) IterateBorrowInterestFactors(ctx sdk.Context, cb func(denom string, factor sdk.Dec) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.key), types.BorrowInterestFactorPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var factor sdk.DecProto
k.cdc.MustUnmarshal(iterator.Value(), &factor)
if cb(string(iterator.Key()), factor.Dec) {
break
}
}
}
// GetSupplyInterestFactor returns the current supply interest factor for an individual market
func (k Keeper) GetSupplyInterestFactor(ctx sdk.Context, denom string) (sdk.Dec, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.SupplyInterestFactorPrefix)
bz := store.Get([]byte(denom))
if len(bz) == 0 {
return sdk.ZeroDec(), false
}
var supplyInterestFactor sdk.DecProto
k.cdc.MustUnmarshal(bz, &supplyInterestFactor)
return supplyInterestFactor.Dec, true
}
// SetSupplyInterestFactor sets the current supply interest factor for an individual market
func (k Keeper) SetSupplyInterestFactor(ctx sdk.Context, denom string, supplyInterestFactor sdk.Dec) {
store := prefix.NewStore(ctx.KVStore(k.key), types.SupplyInterestFactorPrefix)
bz := k.cdc.MustMarshal(&sdk.DecProto{Dec: supplyInterestFactor})
store.Set([]byte(denom), bz)
}
// IterateSupplyInterestFactors iterates over all supply interest factors in the store and returns
// both the supply interest factor and the key (denom) it's stored under
func (k Keeper) IterateSupplyInterestFactors(ctx sdk.Context, cb func(denom string, factor sdk.Dec) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.key), types.SupplyInterestFactorPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var factor sdk.DecProto
k.cdc.MustUnmarshal(iterator.Value(), &factor)
if cb(string(iterator.Key()), factor.Dec) {
break
}
}
}