-
Notifications
You must be signed in to change notification settings - Fork 39
/
keys.go
178 lines (155 loc) · 6.72 KB
/
keys.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
package types
import (
"encoding/binary"
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/address"
)
const (
// ModuleName defines the module name
ModuleName = "reward"
// StoreKey defines the primary module store key
StoreKey = ModuleName
// RouterKey is the message route for slashing
RouterKey = ModuleName
// QuerierRoute defines the module's query routing key
QuerierRoute = ModuleName
RewardIDKeyLength = 8
ClaimPeriodIDLength = 8
)
var (
RewardProgramKeyPrefix = []byte{0x01}
RewardProgramIDKey = []byte{0x02}
ClaimPeriodRewardDistributionKeyPrefix = []byte{0x03}
AccountStateAddressLookupKeyPrefix = []byte{0x04}
AccountStateKeyPrefix = []byte{0x05}
)
// GetRewardProgramKey converts a name into key format.
func GetRewardProgramKey(id uint64) []byte {
rewardIDBytes := make([]byte, RewardIDKeyLength)
binary.BigEndian.PutUint64(rewardIDBytes, id)
return append(RewardProgramKeyPrefix, rewardIDBytes...)
}
// GetRewardAccountStateKey converts a reward program id, claim period id, and address into an AccountStateKey
func GetRewardAccountStateKey(rewardID uint64, rewardClaimPeriodID uint64, addr sdk.AccAddress) []byte {
key := AccountStateKeyPrefix
rewardBytes := make([]byte, RewardIDKeyLength)
claimPeriodBytes := make([]byte, ClaimPeriodIDLength)
binary.BigEndian.PutUint64(rewardBytes, rewardID)
binary.BigEndian.PutUint64(claimPeriodBytes, rewardClaimPeriodID)
key = append(key, rewardBytes...)
key = append(key, claimPeriodBytes...)
key = append(key, address.MustLengthPrefix(addr)...)
return key
}
// GetRewardAccountStateAddressLookupKey facilitates lookup of AccountState via address
func GetRewardAccountStateAddressLookupKey(addr sdk.AccAddress, rewardID uint64, rewardClaimPeriodID uint64) []byte {
key := AccountStateAddressLookupKeyPrefix
rewardBytes := make([]byte, RewardIDKeyLength)
claimPeriodBytes := make([]byte, ClaimPeriodIDLength)
binary.BigEndian.PutUint64(rewardBytes, rewardID)
binary.BigEndian.PutUint64(claimPeriodBytes, rewardClaimPeriodID)
key = append(key, address.MustLengthPrefix(addr)...)
key = append(key, rewardBytes...)
key = append(key, claimPeriodBytes...)
return key
}
// GetRewardAccountStateClaimPeriodKey converts a reward program id and claim period into a prefix for iterating
func GetRewardAccountStateClaimPeriodKey(rewardID uint64, rewardClaimPeriodID uint64) []byte {
key := AccountStateKeyPrefix
rewardBytes := make([]byte, RewardIDKeyLength)
claimPeriodBytes := make([]byte, ClaimPeriodIDLength)
binary.BigEndian.PutUint64(rewardBytes, rewardID)
binary.BigEndian.PutUint64(claimPeriodBytes, rewardClaimPeriodID)
key = append(key, rewardBytes...)
key = append(key, claimPeriodBytes...)
return key
}
// GetRewardProgramRewardAccountStateKey returns the key to iterate over all RewardAccountStates for a RewardProgram
func GetRewardProgramRewardAccountStateKey(rewardID uint64) []byte {
key := AccountStateKeyPrefix
rewardBytes := make([]byte, RewardIDKeyLength)
binary.BigEndian.PutUint64(rewardBytes, rewardID)
key = append(key, rewardBytes...)
return key
}
// GetAllRewardAccountStateKey returns the key to iterate over all AccountStates
func GetAllRewardAccountStateKey() []byte {
key := AccountStateKeyPrefix
return key
}
// GetRewardProgramIDBytes returns the byte representation of the rewardprogramID
func GetRewardProgramIDBytes(rewardprogramID uint64) (rewardprogramIDBz []byte) {
rewardprogramIDBz = make([]byte, RewardIDKeyLength)
binary.BigEndian.PutUint64(rewardprogramIDBz, rewardprogramID)
return
}
// GetRewardProgramIDFromBytes returns rewardprogramID in uint64 format from a byte array
func GetRewardProgramIDFromBytes(bz []byte) (rewardprogramID uint64) {
return binary.BigEndian.Uint64(bz)
}
// GetClaimPeriodRewardDistributionKey returns claim period reward distribution key
func GetClaimPeriodRewardDistributionKey(claimID uint64, rewardID uint64) []byte {
claimBytes := make([]byte, 8)
rewardBytes := make([]byte, 8)
key := ClaimPeriodRewardDistributionKeyPrefix
binary.BigEndian.PutUint64(rewardBytes, rewardID)
binary.BigEndian.PutUint64(claimBytes, claimID)
key = append(key, rewardBytes...)
return append(key, claimBytes...)
}
// GetAllRewardAccountByAddressPartialKey returns the key to iterate over all AccountStateAddressLookup by address
func GetAllRewardAccountByAddressPartialKey(addr sdk.AccAddress) []byte {
key := AccountStateAddressLookupKeyPrefix
key = append(key, address.MustLengthPrefix(addr)...)
return key
}
// GetAllRewardAccountByAddressAndRewardsIDPartialKey returns the key to iterate over all AccountStateAddressLookup by address and rewards id
func GetAllRewardAccountByAddressAndRewardsIDPartialKey(addr sdk.AccAddress, rewardID uint64) []byte {
key := AccountStateAddressLookupKeyPrefix
rewardBytes := make([]byte, RewardIDKeyLength)
binary.BigEndian.PutUint64(rewardBytes, rewardID)
key = append(key, address.MustLengthPrefix(addr.Bytes())...)
key = append(key, rewardBytes...)
return key
}
// MustAccAddressFromBech32 converts a Bech32 address to sdk.AccAddress
// Panics on error
func MustAccAddressFromBech32(s string) sdk.AccAddress {
accAddress, err := sdk.AccAddressFromBech32(s)
if err != nil {
panic(err)
}
return accAddress
}
// ParseFilterLookUpKey splits the provided key into a reward id and claim id and returns them in a RewardAccountLookup along with the provided address.
func ParseFilterLookUpKey(accountStateAddressLookupKey []byte, addr sdk.AccAddress) (RewardAccountLookup, error) {
rewardID := binary.BigEndian.Uint64(accountStateAddressLookupKey[0:8])
claimID := binary.BigEndian.Uint64(accountStateAddressLookupKey[8:16])
return RewardAccountLookup{
Addr: addr,
RewardID: rewardID,
ClaimID: claimID,
}, nil
}
// ParseRewardAccountLookUpKey parse key generated like via GetRewardAccountStateAddressLookupKey(address, rewardProgramId, claimPeriodId)
func ParseRewardAccountLookUpKey(accountStateAddressLookupKey []byte, addr sdk.AccAddress) (RewardAccountLookup, error) {
// address length is stored in first byte
lengthOfAddress := int64(accountStateAddressLookupKey[1:2][0])
address := sdk.AccAddress(accountStateAddressLookupKey[2 : lengthOfAddress+2])
if !addr.Equals(address) {
return RewardAccountLookup{}, fmt.Errorf("addresses do not match up")
}
rewardID := binary.BigEndian.Uint64(accountStateAddressLookupKey[lengthOfAddress+2 : lengthOfAddress+2+RewardIDKeyLength])
claimID := binary.BigEndian.Uint64(accountStateAddressLookupKey[lengthOfAddress+2+RewardIDKeyLength : lengthOfAddress+2+RewardIDKeyLength+ClaimPeriodIDLength])
return RewardAccountLookup{
Addr: addr,
RewardID: rewardID,
ClaimID: claimID,
}, nil
}
type RewardAccountLookup struct {
Addr sdk.Address
RewardID uint64
ClaimID uint64
}