store.gno
15.21 Kb ยท 571 lines
1package staker
2
3import (
4 "strconv"
5
6 "gno.land/p/gnoswap/store"
7 "gno.land/p/nt/avl"
8 "gno.land/p/nt/ufmt"
9)
10
11type StoreKey string
12
13func (s StoreKey) String() string {
14 return string(s)
15}
16
17const (
18 StoreKeyDepositGnsAmount StoreKey = "depositGnsAmount"
19 StoreKeyMinimumRewardAmount StoreKey = "minimumRewardAmount"
20 StoreKeyDeposits StoreKey = "deposits"
21 StoreKeyExternalIncentives StoreKey = "externalIncentives"
22 StoreKeyStakers StoreKey = "stakers"
23 StoreKeyTotalEmissionSent StoreKey = "totalEmissionSent"
24 StoreKeyAllowedTokens StoreKey = "allowedTokens"
25 StoreKeyIncentiveCounter StoreKey = "incentiveCounter"
26 StoreKeyTokenSpecificMinimumRewards StoreKey = "tokenSpecificMinimumRewards"
27 StoreKeyUnstakingFee StoreKey = "unstakingFee"
28 StoreKeyPools StoreKey = "pools"
29 StoreKeyPoolTierMemberships StoreKey = "poolTierMemberships"
30 StoreKeyPoolTierRatio StoreKey = "poolTierRatio"
31 StoreKeyPoolTierCounts StoreKey = "poolTierCounts"
32 StoreKeyPoolTierLastRewardCacheTimestamp StoreKey = "poolTierLastRewardCacheTimestamp"
33 StoreKeyPoolTierLastRewardCacheHeight StoreKey = "poolTierLastRewardCacheHeight"
34 StoreKeyPoolTierCurrentEmission StoreKey = "poolTierCurrentEmission"
35 StoreKeyPoolTierGetEmission StoreKey = "poolTierGetEmission"
36 StoreKeyPoolTierGetHalvingBlocksInRange StoreKey = "poolTierGetHalvingBlocksInRange"
37 StoreKeyWarmupTemplate StoreKey = "warmupTemplate"
38 StoreKeyCurrentSwapBatch StoreKey = "currentSwapBatch"
39 StoreKeyExternalIncentivesByCreationTime StoreKey = "externalIncentivesByCreationTime"
40)
41
42type stakerStore struct {
43 kvStore store.KVStore
44}
45
46// DepositGnsAmount
47func (s *stakerStore) HasDepositGnsAmountStoreKey() bool {
48 return s.kvStore.Has(StoreKeyDepositGnsAmount.String())
49}
50
51func (s *stakerStore) GetDepositGnsAmount() int64 {
52 result, err := s.kvStore.Get(StoreKeyDepositGnsAmount.String())
53 if err != nil {
54 panic(err)
55 }
56
57 amount, ok := result.(int64)
58 if !ok {
59 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
60 }
61
62 return amount
63}
64
65func (s *stakerStore) SetDepositGnsAmount(amount int64) error {
66 return s.kvStore.Set(StoreKeyDepositGnsAmount.String(), amount)
67}
68
69// MinimumRewardAmount
70func (s *stakerStore) HasMinimumRewardAmountStoreKey() bool {
71 return s.kvStore.Has(StoreKeyMinimumRewardAmount.String())
72}
73
74func (s *stakerStore) GetMinimumRewardAmount() int64 {
75 result, err := s.kvStore.Get(StoreKeyMinimumRewardAmount.String())
76 if err != nil {
77 panic(err)
78 }
79
80 amount, ok := result.(int64)
81 if !ok {
82 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
83 }
84
85 return amount
86}
87
88func (s *stakerStore) SetMinimumRewardAmount(amount int64) error {
89 return s.kvStore.Set(StoreKeyMinimumRewardAmount.String(), amount)
90}
91
92// Deposits
93func (s *stakerStore) HasDepositsStoreKey() bool {
94 return s.kvStore.Has(StoreKeyDeposits.String())
95}
96
97func (s *stakerStore) GetDeposits() *avl.Tree {
98 result, err := s.kvStore.Get(StoreKeyDeposits.String())
99 if err != nil {
100 panic(err)
101 }
102
103 deposits, ok := result.(*avl.Tree)
104 if !ok {
105 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
106 }
107
108 return deposits
109}
110
111func (s *stakerStore) SetDeposits(deposits *avl.Tree) error {
112 return s.kvStore.Set(StoreKeyDeposits.String(), deposits)
113}
114
115// ExternalIncentives
116func (s *stakerStore) HasExternalIncentivesStoreKey() bool {
117 return s.kvStore.Has(StoreKeyExternalIncentives.String())
118}
119
120func (s *stakerStore) GetExternalIncentives() *avl.Tree {
121 result, err := s.kvStore.Get(StoreKeyExternalIncentives.String())
122 if err != nil {
123 panic(err)
124 }
125
126 incentives, ok := result.(*avl.Tree)
127 if !ok {
128 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
129 }
130
131 return incentives
132}
133
134func (s *stakerStore) SetExternalIncentives(incentives *avl.Tree) error {
135 return s.kvStore.Set(StoreKeyExternalIncentives.String(), incentives)
136}
137
138// Stakers
139func (s *stakerStore) HasStakersStoreKey() bool {
140 return s.kvStore.Has(StoreKeyStakers.String())
141}
142
143func (s *stakerStore) GetStakers() *avl.Tree {
144 result, err := s.kvStore.Get(StoreKeyStakers.String())
145 if err != nil {
146 panic(err)
147 }
148
149 stakers, ok := result.(*avl.Tree)
150 if !ok {
151 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
152 }
153
154 return stakers
155}
156
157func (s *stakerStore) SetStakers(stakers *avl.Tree) error {
158 return s.kvStore.Set(StoreKeyStakers.String(), stakers)
159}
160
161// TotalEmissionSent
162func (s *stakerStore) HasTotalEmissionSentStoreKey() bool {
163 return s.kvStore.Has(StoreKeyTotalEmissionSent.String())
164}
165
166func (s *stakerStore) GetTotalEmissionSent() int64 {
167 result, err := s.kvStore.Get(StoreKeyTotalEmissionSent.String())
168 if err != nil {
169 panic(err)
170 }
171
172 amount, ok := result.(int64)
173 if !ok {
174 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
175 }
176
177 return amount
178}
179
180func (s *stakerStore) SetTotalEmissionSent(amount int64) error {
181 return s.kvStore.Set(StoreKeyTotalEmissionSent.String(), amount)
182}
183
184// AllowedTokens
185func (s *stakerStore) HasAllowedTokensStoreKey() bool {
186 return s.kvStore.Has(StoreKeyAllowedTokens.String())
187}
188
189func (s *stakerStore) GetAllowedTokens() []string {
190 result, err := s.kvStore.Get(StoreKeyAllowedTokens.String())
191 if err != nil {
192 panic(err)
193 }
194
195 tokens, ok := result.([]string)
196 if !ok {
197 panic(ufmt.Sprintf("failed to cast result to []string: %T", result))
198 }
199
200 return tokens
201}
202
203func (s *stakerStore) SetAllowedTokens(tokens []string) error {
204 return s.kvStore.Set(StoreKeyAllowedTokens.String(), tokens)
205}
206
207// IncentiveCounter
208func (s *stakerStore) HasIncentiveCounterStoreKey() bool {
209 return s.kvStore.Has(StoreKeyIncentiveCounter.String())
210}
211
212func (s *stakerStore) GetIncentiveCounter() *Counter {
213 result, err := s.kvStore.Get(StoreKeyIncentiveCounter.String())
214 if err != nil {
215 panic(err)
216 }
217
218 counter, ok := result.(*Counter)
219 if !ok {
220 panic(ufmt.Sprintf("failed to cast result to *Counter: %T", result))
221 }
222
223 return counter
224}
225
226func (s *stakerStore) SetIncentiveCounter(counter *Counter) error {
227 return s.kvStore.Set(StoreKeyIncentiveCounter.String(), counter)
228}
229
230func (s *stakerStore) NextIncentiveID(creator address, timestamp int64) string {
231 counter := s.GetIncentiveCounter()
232 return makeIncentiveID(creator, timestamp, counter.Next())
233}
234
235// TokenSpecificMinimumRewards
236func (s *stakerStore) HasTokenSpecificMinimumRewardsStoreKey() bool {
237 return s.kvStore.Has(StoreKeyTokenSpecificMinimumRewards.String())
238}
239
240func (s *stakerStore) GetTokenSpecificMinimumRewards() *avl.Tree {
241 result, err := s.kvStore.Get(StoreKeyTokenSpecificMinimumRewards.String())
242 if err != nil {
243 panic(err)
244 }
245
246 rewards, ok := result.(*avl.Tree)
247 if !ok {
248 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
249 }
250
251 return rewards
252}
253
254func (s *stakerStore) SetTokenSpecificMinimumRewards(rewards *avl.Tree) error {
255 return s.kvStore.Set(StoreKeyTokenSpecificMinimumRewards.String(), rewards)
256}
257
258// UnstakingFee
259func (s *stakerStore) HasUnstakingFeeStoreKey() bool {
260 return s.kvStore.Has(StoreKeyUnstakingFee.String())
261}
262
263func (s *stakerStore) GetUnstakingFee() int64 {
264 result, err := s.kvStore.Get(StoreKeyUnstakingFee.String())
265 if err != nil {
266 panic(err)
267 }
268
269 fee, ok := result.(int64)
270 if !ok {
271 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
272 }
273
274 return fee
275}
276
277func (s *stakerStore) SetUnstakingFee(fee int64) error {
278 return s.kvStore.Set(StoreKeyUnstakingFee.String(), fee)
279}
280
281// Pools
282func (s *stakerStore) HasPoolsStoreKey() bool {
283 return s.kvStore.Has(StoreKeyPools.String())
284}
285
286func (s *stakerStore) GetPools() *avl.Tree {
287 result, err := s.kvStore.Get(StoreKeyPools.String())
288 if err != nil {
289 panic(err)
290 }
291
292 pools, ok := result.(*avl.Tree)
293 if !ok {
294 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
295 }
296
297 return pools
298}
299
300func (s *stakerStore) SetPools(pools *avl.Tree) error {
301 return s.kvStore.Set(StoreKeyPools.String(), pools)
302}
303
304// PoolTierMemberships
305func (s *stakerStore) HasPoolTierMembershipsStoreKey() bool {
306 return s.kvStore.Has(StoreKeyPoolTierMemberships.String())
307}
308
309func (s *stakerStore) GetPoolTierMemberships() *avl.Tree {
310 result, err := s.kvStore.Get(StoreKeyPoolTierMemberships.String())
311 if err != nil {
312 panic(err)
313 }
314
315 memberships, ok := result.(*avl.Tree)
316 if !ok {
317 panic(ufmt.Sprintf("failed to cast result to *avl.Tree: %T", result))
318 }
319
320 return memberships
321}
322
323func (s *stakerStore) SetPoolTierMemberships(memberships *avl.Tree) error {
324 return s.kvStore.Set(StoreKeyPoolTierMemberships.String(), memberships)
325}
326
327// PoolTierRatio
328func (s *stakerStore) HasPoolTierRatioStoreKey() bool {
329 return s.kvStore.Has(StoreKeyPoolTierRatio.String())
330}
331
332func (s *stakerStore) GetPoolTierRatio() TierRatio {
333 result, err := s.kvStore.Get(StoreKeyPoolTierRatio.String())
334 if err != nil {
335 panic(err)
336 }
337
338 ratio, ok := result.(TierRatio)
339 if !ok {
340 panic(ufmt.Sprintf("failed to cast result to TierRatio: %T", result))
341 }
342
343 return ratio
344}
345
346func (s *stakerStore) SetPoolTierRatio(ratio TierRatio) error {
347 return s.kvStore.Set(StoreKeyPoolTierRatio.String(), ratio)
348}
349
350// PoolTierCounts
351func (s *stakerStore) HasPoolTierCountsStoreKey() bool {
352 return s.kvStore.Has(StoreKeyPoolTierCounts.String())
353}
354
355func (s *stakerStore) GetPoolTierCounts() [AllTierCount]uint64 {
356 result, err := s.kvStore.Get(StoreKeyPoolTierCounts.String())
357 if err != nil {
358 panic(err)
359 }
360
361 counts, ok := result.([AllTierCount]uint64)
362 if !ok {
363 panic(ufmt.Sprintf("failed to cast result to [AllTierCount]uint64: %T", result))
364 }
365
366 return counts
367}
368
369func (s *stakerStore) SetPoolTierCounts(counts [AllTierCount]uint64) error {
370 return s.kvStore.Set(StoreKeyPoolTierCounts.String(), counts)
371}
372
373// PoolTierLastRewardCacheTimestamp
374func (s *stakerStore) HasPoolTierLastRewardCacheTimestampStoreKey() bool {
375 return s.kvStore.Has(StoreKeyPoolTierLastRewardCacheTimestamp.String())
376}
377
378func (s *stakerStore) GetPoolTierLastRewardCacheTimestamp() int64 {
379 result, err := s.kvStore.Get(StoreKeyPoolTierLastRewardCacheTimestamp.String())
380 if err != nil {
381 panic(err)
382 }
383
384 timestamp, ok := result.(int64)
385 if !ok {
386 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
387 }
388
389 return timestamp
390}
391
392func (s *stakerStore) SetPoolTierLastRewardCacheTimestamp(timestamp int64) error {
393 return s.kvStore.Set(StoreKeyPoolTierLastRewardCacheTimestamp.String(), timestamp)
394}
395
396// PoolTierLastRewardCacheHeight
397func (s *stakerStore) HasPoolTierLastRewardCacheHeightStoreKey() bool {
398 return s.kvStore.Has(StoreKeyPoolTierLastRewardCacheHeight.String())
399}
400
401func (s *stakerStore) GetPoolTierLastRewardCacheHeight() int64 {
402 result, err := s.kvStore.Get(StoreKeyPoolTierLastRewardCacheHeight.String())
403 if err != nil {
404 panic(err)
405 }
406
407 height, ok := result.(int64)
408 if !ok {
409 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
410 }
411
412 return height
413}
414
415func (s *stakerStore) SetPoolTierLastRewardCacheHeight(height int64) error {
416 return s.kvStore.Set(StoreKeyPoolTierLastRewardCacheHeight.String(), height)
417}
418
419// PoolTierCurrentEmission
420func (s *stakerStore) HasPoolTierCurrentEmissionStoreKey() bool {
421 return s.kvStore.Has(StoreKeyPoolTierCurrentEmission.String())
422}
423
424func (s *stakerStore) GetPoolTierCurrentEmission() int64 {
425 result, err := s.kvStore.Get(StoreKeyPoolTierCurrentEmission.String())
426 if err != nil {
427 panic(err)
428 }
429
430 emission, ok := result.(int64)
431 if !ok {
432 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
433 }
434
435 return emission
436}
437
438func (s *stakerStore) SetPoolTierCurrentEmission(emission int64) error {
439 return s.kvStore.Set(StoreKeyPoolTierCurrentEmission.String(), emission)
440}
441
442// PoolTierGetEmission
443func (s *stakerStore) HasPoolTierGetEmissionStoreKey() bool {
444 return s.kvStore.Has(StoreKeyPoolTierGetEmission.String())
445}
446
447func (s *stakerStore) GetPoolTierGetEmission() func() int64 {
448 result, err := s.kvStore.Get(StoreKeyPoolTierGetEmission.String())
449 if err != nil {
450 panic(err)
451 }
452
453 fn, ok := result.(func() int64)
454 if !ok {
455 panic(ufmt.Sprintf("failed to cast result to func() int64: %T", result))
456 }
457
458 return fn
459}
460
461func (s *stakerStore) SetPoolTierGetEmission(fn func() int64) error {
462 return s.kvStore.Set(StoreKeyPoolTierGetEmission.String(), fn)
463}
464
465// PoolTierGetHalvingBlocksInRange
466func (s *stakerStore) HasPoolTierGetHalvingBlocksInRangeStoreKey() bool {
467 return s.kvStore.Has(StoreKeyPoolTierGetHalvingBlocksInRange.String())
468}
469
470func (s *stakerStore) GetPoolTierGetHalvingBlocksInRange() func(start, end int64) ([]int64, []int64) {
471 result, err := s.kvStore.Get(StoreKeyPoolTierGetHalvingBlocksInRange.String())
472 if err != nil {
473 panic(err)
474 }
475
476 fn, ok := result.(func(start, end int64) ([]int64, []int64))
477 if !ok {
478 panic(ufmt.Sprintf("failed to cast result to func(start, end int64) ([]int64, []int64): %T", result))
479 }
480
481 return fn
482}
483
484func (s *stakerStore) SetPoolTierGetHalvingBlocksInRange(fn func(start, end int64) ([]int64, []int64)) error {
485 return s.kvStore.Set(StoreKeyPoolTierGetHalvingBlocksInRange.String(), fn)
486}
487
488func (s *stakerStore) HasWarmupTemplateStoreKey() bool {
489 return s.kvStore.Has(StoreKeyWarmupTemplate.String())
490}
491
492func (s *stakerStore) GetWarmupTemplate() []Warmup {
493 result, err := s.kvStore.Get(StoreKeyWarmupTemplate.String())
494 if err != nil {
495 panic(err)
496 }
497
498 warmups, ok := result.([]Warmup)
499 if !ok {
500 panic(ufmt.Sprintf("failed to cast result to []Warmup: %T", result))
501 }
502
503 return warmups
504}
505
506func (s *stakerStore) SetWarmupTemplate(warmups []Warmup) error {
507 return s.kvStore.Set(StoreKeyWarmupTemplate.String(), warmups)
508}
509
510// CurrentSwapBatch
511func (s *stakerStore) HasCurrentSwapBatchStoreKey() bool {
512 return s.kvStore.Has(StoreKeyCurrentSwapBatch.String())
513}
514
515func (s *stakerStore) GetCurrentSwapBatch() *SwapBatchProcessor {
516 result, err := s.kvStore.Get(StoreKeyCurrentSwapBatch.String())
517 if err != nil {
518 panic(err)
519 }
520
521 batch, ok := result.(*SwapBatchProcessor)
522 if !ok {
523 panic(ufmt.Sprintf("failed to cast result to *SwapBatchProcessor: %T", result))
524 }
525
526 return batch
527}
528
529func (s *stakerStore) SetCurrentSwapBatch(batch *SwapBatchProcessor) error {
530 return s.kvStore.Set(StoreKeyCurrentSwapBatch.String(), batch)
531}
532
533// ExternalIncentivesByCreationTime
534// key: timestamp -> value: *avl.Tree (poolPath -> []string)
535func (s *stakerStore) HasExternalIncentivesByCreationTimeStoreKey() bool {
536 return s.kvStore.Has(StoreKeyExternalIncentivesByCreationTime.String())
537}
538
539func (s *stakerStore) GetExternalIncentivesByCreationTime() *UintTree {
540 result, err := s.kvStore.Get(StoreKeyExternalIncentivesByCreationTime.String())
541 if err != nil {
542 panic(err)
543 }
544
545 tree, ok := result.(*UintTree)
546 if !ok {
547 panic(ufmt.Sprintf("failed to cast result to *UintTree: %T", result))
548 }
549
550 return tree
551}
552
553func (s *stakerStore) SetExternalIncentivesByCreationTime(tree *UintTree) error {
554 return s.kvStore.Set(StoreKeyExternalIncentivesByCreationTime.String(), tree)
555}
556
557// NewStakerStore creates a new staker store instance with the provided KV store.
558// This function is used by the upgrade system to create storage instances for each implementation.
559func NewStakerStore(kvStore store.KVStore) IStakerStore {
560 return &stakerStore{
561 kvStore: kvStore,
562 }
563}
564
565func uint64ToString(id uint64) string {
566 return strconv.FormatUint(id, 10)
567}
568
569func makeIncentiveID(creator address, timestamp int64, index int64) string {
570 return ufmt.Sprintf("%s:%d:%d", creator.String(), timestamp, index)
571}
