store.gno
9.83 Kb · 378 lines
1package staker
2
3import (
4 "errors"
5 "gno.land/p/gnoswap/store"
6 "gno.land/p/gnoswap/utils"
7 bptree "gno.land/p/nt/bptree/v0"
8 ufmt "gno.land/p/nt/ufmt/v0"
9)
10
11// Storage key constants
12const (
13 // Basic configuration
14 StoreKeyUnDelegationLockupPeriod = "unDelegationLockupPeriod"
15 StoreKeyTotalDelegatedAmount = "totalDelegatedAmount"
16 StoreKeyTotalLockedAmount = "totalLockedAmount"
17
18 // Counters
19 StoreKeyDelegationNextID = "delegationNextID"
20
21 // Complex data structures
22 StoreKeyDelegations = "delegations" // BPTree of delegations
23 StoreKeyTotalDelegationHistory = "totalDelegationHistory" // UintTree: timestamp -> int64 (cumulative total)
24 StoreKeyUserDelegationHistory = "userDelegationHistory" // BPTree: address -> *UintTree[timestamp -> int64]
25
26 // Manager states
27 StoreKeyEmissionRewardManager = "emissionRewardManager"
28 StoreKeyProtocolFeeRewardManager = "protocolFeeRewardManager"
29 StoreKeyDelegationManager = "delegationManager"
30 StoreKeyLaunchpadProjectDeposits = "launchpadProjectDeposits"
31)
32
33// govStakerStore is the concrete implementation of IGovStakerStore
34type govStakerStore struct {
35 kvStore store.KVStore
36}
37
38var _ IGovStakerStore = (*govStakerStore)(nil)
39
40// NewGovStakerStore creates a new governance staker store instance
41func NewGovStakerStore(kvStore store.KVStore) IGovStakerStore {
42 return &govStakerStore{
43 kvStore: kvStore,
44 }
45}
46
47// Basic configuration methods
48func (s *govStakerStore) HasUnDelegationLockupPeriodStoreKey() bool {
49 return s.kvStore.Has(StoreKeyUnDelegationLockupPeriod)
50}
51
52func (s *govStakerStore) GetUnDelegationLockupPeriod() int64 {
53 result, err := s.kvStore.Get(StoreKeyUnDelegationLockupPeriod)
54 if err != nil {
55 panic(err)
56 }
57
58 period, ok := result.(int64)
59 if !ok {
60 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
61 }
62
63 return period
64}
65
66func (s *govStakerStore) SetUnDelegationLockupPeriod(_ int, rlm realm, period int64) error {
67 if !rlm.IsCurrent() {
68 return errors.New(ErrSpoofedRealm)
69 }
70
71 return s.kvStore.Set(0, rlm, StoreKeyUnDelegationLockupPeriod, period)
72}
73
74func (s *govStakerStore) HasTotalDelegatedAmountStoreKey() bool {
75 return s.kvStore.Has(StoreKeyTotalDelegatedAmount)
76}
77
78func (s *govStakerStore) GetTotalDelegatedAmount() int64 {
79 result, err := s.kvStore.Get(StoreKeyTotalDelegatedAmount)
80 if err != nil {
81 panic(err)
82 }
83
84 amount, ok := result.(int64)
85 if !ok {
86 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
87 }
88
89 return amount
90}
91
92func (s *govStakerStore) SetTotalDelegatedAmount(_ int, rlm realm, amount int64) error {
93 if !rlm.IsCurrent() {
94 return errors.New(ErrSpoofedRealm)
95 }
96
97 return s.kvStore.Set(0, rlm, StoreKeyTotalDelegatedAmount, amount)
98}
99
100func (s *govStakerStore) HasTotalLockedAmountStoreKey() bool {
101 return s.kvStore.Has(StoreKeyTotalLockedAmount)
102}
103
104func (s *govStakerStore) GetTotalLockedAmount() int64 {
105 result, err := s.kvStore.Get(StoreKeyTotalLockedAmount)
106 if err != nil {
107 panic(err)
108 }
109
110 amount, ok := result.(int64)
111 if !ok {
112 panic(ufmt.Sprintf("failed to cast result to int64: %T", result))
113 }
114
115 return amount
116}
117
118func (s *govStakerStore) SetTotalLockedAmount(_ int, rlm realm, amount int64) error {
119 if !rlm.IsCurrent() {
120 return errors.New(ErrSpoofedRealm)
121 }
122
123 return s.kvStore.Set(0, rlm, StoreKeyTotalLockedAmount, amount)
124}
125
126// Delegation management methods
127func (s *govStakerStore) HasDelegationsStoreKey() bool {
128 return s.kvStore.Has(StoreKeyDelegations)
129}
130
131func (s *govStakerStore) SetDelegations(_ int, rlm realm, delegations *bptree.BPTree) error {
132 if !rlm.IsCurrent() {
133 return errors.New(ErrSpoofedRealm)
134 }
135
136 return s.kvStore.Set(0, rlm, StoreKeyDelegations, delegations)
137}
138
139func (s *govStakerStore) HasDelegation(id int64) bool {
140 delegations := s.GetAllDelegations()
141 return delegations.Get(utils.Int64ToString(id)) != nil
142}
143
144func (s *govStakerStore) GetDelegation(id int64) (*Delegation, bool) {
145 delegations := s.GetAllDelegations()
146
147 result := delegations.Get(utils.Int64ToString(id))
148 if result == nil {
149 return nil, false
150 }
151
152 delegation, ok := result.(*Delegation)
153 if !ok {
154 panic(ufmt.Sprintf("failed to cast result to *Delegation: %T", result))
155 }
156
157 return delegation, true
158}
159
160func (s *govStakerStore) SetDelegation(_ int, rlm realm, id int64, delegation *Delegation) error {
161 if !rlm.IsCurrent() {
162 return errors.New(ErrSpoofedRealm)
163 }
164
165 delegations := s.GetAllDelegations()
166
167 delegations.Set(utils.Int64ToString(id), delegation)
168 return s.kvStore.Set(0, rlm, StoreKeyDelegations, delegations)
169}
170
171func (s *govStakerStore) RemoveDelegation(_ int, rlm realm, id int64) error {
172 if !rlm.IsCurrent() {
173 return errors.New(ErrSpoofedRealm)
174 }
175
176 delegations := s.GetAllDelegations()
177
178 delegations.Remove(utils.Int64ToString(id))
179 return s.kvStore.Set(0, rlm, StoreKeyDelegations, delegations)
180}
181
182func (s *govStakerStore) GetAllDelegations() *bptree.BPTree {
183 result, err := s.kvStore.Get(StoreKeyDelegations)
184 if err != nil {
185 panic(err)
186 }
187
188 delegations, ok := result.(*bptree.BPTree)
189 if !ok {
190 panic(ufmt.Sprintf("failed to cast result to *bptree.BPTree: %T", result))
191 }
192
193 return delegations
194}
195
196func (s *govStakerStore) HasDelegationCounterStoreKey() bool {
197 return s.kvStore.Has(StoreKeyDelegationNextID)
198}
199
200func (s *govStakerStore) GetDelegationCounter() *Counter {
201 result, err := s.kvStore.Get(StoreKeyDelegationNextID)
202 if err != nil {
203 panic(err)
204 }
205
206 counter, ok := result.(*Counter)
207 if !ok {
208 panic(ufmt.Sprintf("failed to cast result to Counter: %T", result))
209 }
210
211 return counter
212}
213
214func (s *govStakerStore) SetDelegationCounter(_ int, rlm realm, counter *Counter) error {
215 if !rlm.IsCurrent() {
216 return errors.New(ErrSpoofedRealm)
217 }
218
219 return s.kvStore.Set(0, rlm, StoreKeyDelegationNextID, counter)
220}
221
222// Total delegation history methods (timestamp -> int64)
223func (s *govStakerStore) HasTotalDelegationHistoryStoreKey() bool {
224 return s.kvStore.Has(StoreKeyTotalDelegationHistory)
225}
226
227func (s *govStakerStore) GetTotalDelegationHistory() *UintTree {
228 result, err := s.kvStore.Get(StoreKeyTotalDelegationHistory)
229 if err != nil {
230 panic(err)
231 }
232
233 history, ok := result.(*UintTree)
234 if !ok {
235 panic(ufmt.Sprintf("failed to cast result to *UintTree: %T", result))
236 }
237
238 return history
239}
240
241func (s *govStakerStore) SetTotalDelegationHistory(_ int, rlm realm, history *UintTree) error {
242 if !rlm.IsCurrent() {
243 return errors.New(ErrSpoofedRealm)
244 }
245
246 return s.kvStore.Set(0, rlm, StoreKeyTotalDelegationHistory, history)
247}
248
249// User delegation history methods (address -> *UintTree[timestamp -> int64])
250func (s *govStakerStore) HasUserDelegationHistoryStoreKey() bool {
251 return s.kvStore.Has(StoreKeyUserDelegationHistory)
252}
253
254func (s *govStakerStore) GetUserDelegationHistory() *bptree.BPTree {
255 result, err := s.kvStore.Get(StoreKeyUserDelegationHistory)
256 if err != nil {
257 panic(err)
258 }
259
260 history, ok := result.(*bptree.BPTree)
261 if !ok {
262 panic(ufmt.Sprintf("failed to cast result to *bptree.BPTree: %T", result))
263 }
264
265 return history
266}
267
268func (s *govStakerStore) SetUserDelegationHistory(_ int, rlm realm, history *bptree.BPTree) error {
269 if !rlm.IsCurrent() {
270 return errors.New(ErrSpoofedRealm)
271 }
272
273 return s.kvStore.Set(0, rlm, StoreKeyUserDelegationHistory, history)
274}
275
276func (s *govStakerStore) HasEmissionRewardManagerStoreKey() bool {
277 return s.kvStore.Has(StoreKeyEmissionRewardManager)
278}
279
280func (s *govStakerStore) GetEmissionRewardManager() *EmissionRewardManager {
281 result, err := s.kvStore.Get(StoreKeyEmissionRewardManager)
282 if err != nil {
283 panic(err)
284 }
285
286 manager, ok := result.(*EmissionRewardManager)
287 if !ok {
288 panic(ufmt.Sprintf("failed to cast result to *EmissionRewardManager: %T", result))
289 }
290
291 return manager
292}
293
294func (s *govStakerStore) SetEmissionRewardManager(_ int, rlm realm, manager *EmissionRewardManager) error {
295 if !rlm.IsCurrent() {
296 return errors.New(ErrSpoofedRealm)
297 }
298
299 return s.kvStore.Set(0, rlm, StoreKeyEmissionRewardManager, manager)
300}
301
302func (s *govStakerStore) HasProtocolFeeRewardManagerStoreKey() bool {
303 return s.kvStore.Has(StoreKeyProtocolFeeRewardManager)
304}
305
306func (s *govStakerStore) GetProtocolFeeRewardManager() *ProtocolFeeRewardManager {
307 result, err := s.kvStore.Get(StoreKeyProtocolFeeRewardManager)
308 if err != nil {
309 panic(err)
310 }
311
312 manager, ok := result.(*ProtocolFeeRewardManager)
313 if !ok {
314 panic(ufmt.Sprintf("failed to cast result to *ProtocolFeeRewardManager: %T", result))
315 }
316
317 return manager
318}
319
320func (s *govStakerStore) SetProtocolFeeRewardManager(_ int, rlm realm, manager *ProtocolFeeRewardManager) error {
321 if !rlm.IsCurrent() {
322 return errors.New(ErrSpoofedRealm)
323 }
324
325 return s.kvStore.Set(0, rlm, StoreKeyProtocolFeeRewardManager, manager)
326}
327
328func (s *govStakerStore) HasDelegationManagerStoreKey() bool {
329 return s.kvStore.Has(StoreKeyDelegationManager)
330}
331
332func (s *govStakerStore) GetDelegationManager() *DelegationManager {
333 result, err := s.kvStore.Get(StoreKeyDelegationManager)
334 if err != nil {
335 panic(err)
336 }
337
338 manager, ok := result.(*DelegationManager)
339 if !ok {
340 panic(ufmt.Sprintf("failed to cast result to *DelegationManager: %T", result))
341 }
342
343 return manager
344}
345
346func (s *govStakerStore) SetDelegationManager(_ int, rlm realm, manager *DelegationManager) error {
347 if !rlm.IsCurrent() {
348 return errors.New(ErrSpoofedRealm)
349 }
350
351 return s.kvStore.Set(0, rlm, StoreKeyDelegationManager, manager)
352}
353
354func (s *govStakerStore) HasLaunchpadProjectDepositsStoreKey() bool {
355 return s.kvStore.Has(StoreKeyLaunchpadProjectDeposits)
356}
357
358func (s *govStakerStore) GetLaunchpadProjectDeposits() *LaunchpadProjectDeposits {
359 result, err := s.kvStore.Get(StoreKeyLaunchpadProjectDeposits)
360 if err != nil {
361 panic(err)
362 }
363
364 deposits, ok := result.(*LaunchpadProjectDeposits)
365 if !ok {
366 panic(ufmt.Sprintf("failed to cast result to *LaunchpadProjectDeposits: %T", result))
367 }
368
369 return deposits
370}
371
372func (s *govStakerStore) SetLaunchpadProjectDeposits(_ int, rlm realm, deposits *LaunchpadProjectDeposits) error {
373 if !rlm.IsCurrent() {
374 return errors.New(ErrSpoofedRealm)
375 }
376
377 return s.kvStore.Set(0, rlm, StoreKeyLaunchpadProjectDeposits, deposits)
378}
