Add AccrualTime type and state methods (#1379)

* Add methods for reward accrual time

* Add accrual time methods

* Add claim type to IterateAllRewardAccrualTimes callback method

* Use new AccrualTime proto type for state methods, add to genesis

* Add GetAllRewardAccrualTimes doc

* Add accrual times to genesis methods

* Remove DecodeKeyPrefix

* Update acrual time iterate method naming

* Update Iterate claims naming

* Use method for sourceID key conversion
This commit is contained in:
Derrick Lee 2022-11-04 16:21:05 -07:00 committed by GitHub
parent 4087941691
commit df1c2ffc34
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 762 additions and 71 deletions

View File

@ -329,6 +329,7 @@
- [RewardPeriod](#kava.incentive.v1beta1.RewardPeriod)
- [kava/incentive/v1beta1/genesis.proto](#kava/incentive/v1beta1/genesis.proto)
- [AccrualTime](#kava.incentive.v1beta1.AccrualTime)
- [AccumulationTime](#kava.incentive.v1beta1.AccumulationTime)
- [GenesisRewardState](#kava.incentive.v1beta1.GenesisRewardState)
- [GenesisState](#kava.incentive.v1beta1.GenesisState)
@ -4778,6 +4779,25 @@ RewardPeriod stores the state of an ongoing reward
<a name="kava.incentive.v1beta1.AccrualTime"></a>
### AccrualTime
AccrualTime stores the previous reward distribution time and its
corresponding collateral type and claim type. This is the new version of
AccumulationTime that is used for the new claim types.
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| `claim_type` | [ClaimType](#kava.incentive.v1beta1.ClaimType) | | |
| `collateral_type` | [string](#string) | | |
| `previous_accumulation_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) | | |
<a name="kava.incentive.v1beta1.AccumulationTime"></a>
### AccumulationTime
@ -4833,6 +4853,7 @@ GenesisState is the state that must be provided at genesis.
| `earn_reward_state` | [GenesisRewardState](#kava.incentive.v1beta1.GenesisRewardState) | | |
| `earn_claims` | [EarnClaim](#kava.incentive.v1beta1.EarnClaim) | repeated | |
| `claims` | [Claim](#kava.incentive.v1beta1.Claim) | repeated | |
| `accrual_times` | [AccrualTime](#kava.incentive.v1beta1.AccrualTime) | repeated | |

View File

@ -15,11 +15,22 @@ option (gogoproto.goproto_getters_all) = false;
// AccumulationTime stores the previous reward distribution time and its corresponding collateral type
message AccumulationTime {
option deprecated = true;
string collateral_type = 1;
google.protobuf.Timestamp previous_accumulation_time = 2 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
}
// AccrualTime stores the previous reward distribution time and its
// corresponding collateral type and claim type. This is the new version of
// AccumulationTime that is used for the new claim types.
message AccrualTime {
ClaimType claim_type = 1;
string collateral_type = 2;
google.protobuf.Timestamp previous_accumulation_time = 3 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
}
// GenesisRewardState groups together the global state for a particular reward so it can be exported in genesis.
message GenesisRewardState {
repeated AccumulationTime accumulation_times = 1
@ -66,4 +77,6 @@ message GenesisState {
repeated EarnClaim earn_claims = 14 [(gogoproto.castrepeated) = "EarnClaims", (gogoproto.nullable) = false];
repeated Claim claims = 15 [(gogoproto.castrepeated) = "Claims", (gogoproto.nullable) = false];
repeated AccrualTime accrual_times = 16 [(gogoproto.castrepeated) = "AccrualTimes", (gogoproto.nullable) = false];
}

View File

@ -49,6 +49,18 @@ func InitGenesis(
k.SetClaim(ctx, claim)
}
// Set AccrualTimes of all types
for _, accrualTime := range gs.AccrualTimes {
k.SetRewardAccrualTime(
ctx,
accrualTime.ClaimType,
accrualTime.CollateralType,
accrualTime.PreviousAccumulationTime,
)
}
// Legacy claims and indexes below
// USDX Minting
for _, claim := range gs.USDXMintingClaims {
k.SetUSDXMintingClaim(ctx, claim)
@ -152,6 +164,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
params := k.GetParams(ctx)
claims := k.GetAllClaims(ctx)
accrualTimes := k.GetAllRewardAccrualTimes(ctx)
usdxClaims := k.GetAllUSDXMintingClaims(ctx)
usdxRewardState := getUSDXMintingGenesisRewardState(ctx, k)
@ -178,6 +191,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
usdxRewardState, hardSupplyRewardState, hardBorrowRewardState, delegatorRewardState, swapRewardState, savingsRewardState, earnRewardState,
// Claims
claims, usdxClaims, hardClaims, delegatorClaims, swapClaims, savingsClaims, earnClaims,
accrualTimes,
)
}

View File

@ -109,6 +109,7 @@ func (suite *GenesisTestSuite) SetupTest() {
types.DefaultSwapClaims,
types.DefaultSavingsClaims,
types.DefaultEarnClaims,
types.DefaultAccrualTimes,
)
cdc := suite.app.AppCodec()
@ -282,6 +283,9 @@ func (suite *GenesisTestSuite) TestExportedGenesisMatchesImported() {
types.MultiRewardIndexes{{CollateralType: "usdx", RewardIndexes: types.RewardIndexes{{CollateralType: "earn", RewardFactor: d("0.0")}}}},
),
},
types.AccrualTimes{
types.NewAccrualTime(types.CLAIM_TYPE_USDX_MINTING, "usdx", genesisTime.Add(-2*time.Hour)),
},
)
tApp := app.NewTestApp()

View File

@ -922,9 +922,9 @@ func (k Keeper) DeleteClaim(
store.Delete(owner)
}
// IterateClaims iterates over all claim objects in the store of a given
// IterateClaimsByClaimType iterates over all claim objects in the store of a given
// claimType and preforms a callback function
func (k Keeper) IterateClaims(
func (k Keeper) IterateClaimsByClaimType(
ctx sdk.Context,
claimType types.ClaimType,
cb func(c types.Claim) (stop bool),
@ -946,7 +946,7 @@ func (k Keeper) GetClaims(
claimType types.ClaimType,
) types.Claims {
var cs types.Claims
k.IterateClaims(ctx, claimType, func(c types.Claim) (stop bool) {
k.IterateClaimsByClaimType(ctx, claimType, func(c types.Claim) (stop bool) {
cs = append(cs, c)
return false
})
@ -954,9 +954,9 @@ func (k Keeper) GetClaims(
return cs
}
// IterateAllClaims iterates over all claim objects of any claimType in the
// IterateClaims iterates over all claim objects of any claimType in the
// store and preforms a callback function
func (k Keeper) IterateAllClaims(
func (k Keeper) IterateClaims(
ctx sdk.Context,
cb func(c types.Claim) (stop bool),
) {
@ -974,10 +974,96 @@ func (k Keeper) IterateAllClaims(
// GetAllClaims returns all Claim objects in the store of any claimType
func (k Keeper) GetAllClaims(ctx sdk.Context) types.Claims {
var cs types.Claims
k.IterateAllClaims(ctx, func(c types.Claim) (stop bool) {
k.IterateClaims(ctx, func(c types.Claim) (stop bool) {
cs = append(cs, c)
return false
})
return cs
}
// GetRewardAccrualTime fetches the last time rewards were accrued for the
// specified ClaimType and sourceID.
func (k Keeper) GetRewardAccrualTime(
ctx sdk.Context,
claimType types.ClaimType,
sourceID string,
) (time.Time, bool) {
store := prefix.NewStore(ctx.KVStore(k.key), types.GetPreviousRewardAccrualTimeKeyPrefix(claimType))
b := store.Get(types.GetKeyFromSourceID(sourceID))
if b == nil {
return time.Time{}, false
}
var accrualTime types.AccrualTime
k.cdc.MustUnmarshal(b, &accrualTime)
return accrualTime.PreviousAccumulationTime, true
}
// SetRewardAccrualTime stores the last time rewards were accrued for the
// specified ClaimType and sourceID.
func (k Keeper) SetRewardAccrualTime(
ctx sdk.Context,
claimType types.ClaimType,
sourceID string,
blockTime time.Time,
) {
store := prefix.NewStore(ctx.KVStore(k.key), types.GetPreviousRewardAccrualTimeKeyPrefix(claimType))
at := types.NewAccrualTime(claimType, sourceID, blockTime)
bz := k.cdc.MustMarshal(&at)
store.Set(types.GetKeyFromSourceID(sourceID), bz)
}
// IterateRewardAccrualTimesByClaimType iterates over all reward accrual times of a given
// claimType and performs a callback function.
func (k Keeper) IterateRewardAccrualTimesByClaimType(
ctx sdk.Context,
claimType types.ClaimType,
cb func(string, time.Time) (stop bool),
) {
store := prefix.NewStore(ctx.KVStore(k.key), types.GetPreviousRewardAccrualTimeKeyPrefix(claimType))
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var accrualTime types.AccrualTime
k.cdc.MustUnmarshal(iterator.Value(), &accrualTime)
if cb(accrualTime.CollateralType, accrualTime.PreviousAccumulationTime) {
break
}
}
}
// IterateRewardAccrualTimes iterates over all reward accrual times of any
// claimType and performs a callback function.
func (k Keeper) IterateRewardAccrualTimes(
ctx sdk.Context,
cb func(types.AccrualTime) (stop bool),
) {
store := prefix.NewStore(ctx.KVStore(k.key), types.PreviousRewardAccrualTimeKeyPrefix)
iterator := sdk.KVStorePrefixIterator(store, []byte{})
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var accrualTime types.AccrualTime
k.cdc.MustUnmarshal(iterator.Value(), &accrualTime)
if cb(accrualTime) {
break
}
}
}
// GetAllRewardAccrualTimes returns all reward accrual times of any claimType.
func (k Keeper) GetAllRewardAccrualTimes(ctx sdk.Context) types.AccrualTimes {
var ats types.AccrualTimes
k.IterateRewardAccrualTimes(
ctx,
func(accrualTime types.AccrualTime) bool {
ats = append(ats, accrualTime)
return false
},
)
return ats
}

View File

@ -1,6 +1,8 @@
package keeper_test
import (
"time"
"github.com/kava-labs/kava/x/incentive/types"
)
@ -85,3 +87,112 @@ func (suite *KeeperTestSuite) TestIterateClaims() {
suite.Require().Len(allClaims, len(claims))
suite.Require().ElementsMatch(allClaims, claims, "GetAllClaims() should return claims of all types")
}
func (suite *KeeperTestSuite) TestGetSetRewardAccrualTimes() {
testCases := []struct {
name string
subKey string
accrualTime time.Time
panics bool
}{
{
name: "normal time can be written and read",
subKey: "btc/usdx",
accrualTime: time.Date(1998, 1, 1, 0, 0, 0, 0, time.UTC),
},
{
name: "zero time can be written and read",
subKey: "btc/usdx",
accrualTime: time.Time{},
},
}
for _, tc := range testCases {
suite.Run(tc.name, func() {
suite.SetupApp()
_, found := suite.keeper.GetRewardAccrualTime(suite.ctx, types.CLAIM_TYPE_USDX_MINTING, tc.subKey)
suite.False(found)
setFunc := func() {
suite.keeper.SetRewardAccrualTime(suite.ctx, types.CLAIM_TYPE_USDX_MINTING, tc.subKey, tc.accrualTime)
}
if tc.panics {
suite.Panics(setFunc)
return
} else {
suite.NotPanics(setFunc)
}
for _, claimTypeValue := range types.ClaimType_value {
claimType := types.ClaimType(claimTypeValue)
if claimType == types.CLAIM_TYPE_USDX_MINTING {
continue
}
_, found := suite.keeper.GetRewardAccrualTime(suite.ctx, claimType, tc.subKey)
suite.False(found, "reward accrual time for claim type %s should not exist", claimType)
}
storedTime, found := suite.keeper.GetRewardAccrualTime(suite.ctx, types.CLAIM_TYPE_USDX_MINTING, tc.subKey)
suite.True(found)
suite.Equal(tc.accrualTime, storedTime)
})
}
}
func (suite *KeeperTestSuite) TestIterateRewardAccrualTimes() {
suite.SetupApp()
expectedAccrualTimes := nonEmptyAccrualTimes
for _, at := range expectedAccrualTimes {
suite.keeper.SetRewardAccrualTime(suite.ctx, types.CLAIM_TYPE_USDX_MINTING, at.denom, at.time)
}
var actualAccrualTimes []accrualtime
suite.keeper.IterateRewardAccrualTimesByClaimType(suite.ctx, types.CLAIM_TYPE_USDX_MINTING, func(denom string, accrualTime time.Time) bool {
actualAccrualTimes = append(actualAccrualTimes, accrualtime{denom: denom, time: accrualTime})
return false
})
suite.ElementsMatch(expectedAccrualTimes, actualAccrualTimes)
}
func (suite *KeeperTestSuite) TestIterateAllRewardAccrualTimes() {
suite.SetupApp()
var expectedAccrualTimes types.AccrualTimes
for _, claimTypeValue := range types.ClaimType_value {
claimType := types.ClaimType(claimTypeValue)
// Skip invalid claim type
if claimType.Validate() != nil {
continue
}
for _, at := range nonEmptyAccrualTimes {
suite.keeper.SetRewardAccrualTime(suite.ctx, claimType, at.denom, at.time)
expectedAccrualTimes = append(expectedAccrualTimes, types.NewAccrualTime(
claimType,
at.denom,
at.time,
))
}
}
var actualAccrualTimes types.AccrualTimes
suite.keeper.IterateRewardAccrualTimes(
suite.ctx,
func(accrualTime types.AccrualTime) bool {
actualAccrualTimes = append(actualAccrualTimes, accrualTime)
return false
},
)
suite.ElementsMatch(expectedAccrualTimes, actualAccrualTimes)
}

View File

@ -6,7 +6,6 @@ import (
)
var (
DefaultClaims = Claims{}
DefaultUSDXClaims = USDXMintingClaims{}
DefaultHardClaims = HardLiquidityProviderClaims{}
DefaultDelegatorClaims = DelegatorClaims{}
@ -17,6 +16,10 @@ var (
MultiRewardIndexes{},
)
DefaultEarnClaims = EarnClaims{}
// New fields
DefaultClaims = Claims{}
DefaultAccrualTimes = AccrualTimes{}
)
// NewGenesisState returns a new genesis state
@ -26,6 +29,7 @@ func NewGenesisState(
c Claims,
uc USDXMintingClaims, hc HardLiquidityProviderClaims, dc DelegatorClaims, sc SwapClaims, savingsc SavingsClaims,
earnc EarnClaims,
accrualTimes AccrualTimes,
) GenesisState {
return GenesisState{
Params: params,
@ -38,14 +42,17 @@ func NewGenesisState(
SavingsRewardState: savingsState,
EarnRewardState: earnState,
// Claims of all types
Claims: c,
USDXMintingClaims: uc,
HardLiquidityProviderClaims: hc,
DelegatorClaims: dc,
SwapClaims: sc,
SavingsClaims: savingsc,
EarnClaims: earnc,
// New fields
// Claims of all types
Claims: c,
AccrualTimes: accrualTimes,
}
}
@ -67,6 +74,7 @@ func DefaultGenesisState() GenesisState {
SwapClaims: DefaultSwapClaims,
SavingsClaims: DefaultSavingsClaims,
EarnClaims: DefaultEarnClaims,
AccrualTimes: DefaultAccrualTimes,
}
}
@ -99,10 +107,6 @@ func (gs GenesisState) Validate() error {
return err
}
if err := gs.Claims.Validate(); err != nil {
return err
}
if err := gs.USDXMintingClaims.Validate(); err != nil {
return err
}
@ -120,7 +124,16 @@ func (gs GenesisState) Validate() error {
return err
}
return gs.EarnClaims.Validate()
if err := gs.EarnClaims.Validate(); err != nil {
return err
}
// Refactored methods -- these will eventually replace the claim and state methods above
if err := gs.Claims.Validate(); err != nil {
return err
}
return gs.AccrualTimes.Validate()
}
// NewGenesisRewardState returns a new GenesisRewardState
@ -167,3 +180,38 @@ func (gats AccumulationTimes) Validate() error {
}
return nil
}
// NewAccrualTime returns a new AccrualTime
func NewAccrualTime(claimType ClaimType, collateralType string, prevTime time.Time) AccrualTime {
return AccrualTime{
ClaimType: claimType,
CollateralType: collateralType,
PreviousAccumulationTime: prevTime,
}
}
// Validate performs validation of AccrualTime
func (at AccrualTime) Validate() error {
if err := at.ClaimType.Validate(); err != nil {
return err
}
if len(at.CollateralType) == 0 {
return fmt.Errorf("collateral type cannot be empty")
}
return nil
}
// AccrualTimes slice of AccrualTime
type AccrualTimes []AccrualTime
// Validate performs validation of AccrualTimes
func (gats AccrualTimes) Validate() error {
for _, gat := range gats {
if err := gat.Validate(); err != nil {
return err
}
}
return nil
}

View File

@ -28,6 +28,8 @@ var _ = time.Kitchen
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// AccumulationTime stores the previous reward distribution time and its corresponding collateral type
//
// Deprecated: Do not use.
type AccumulationTime struct {
CollateralType string `protobuf:"bytes,1,opt,name=collateral_type,json=collateralType,proto3" json:"collateral_type,omitempty"`
PreviousAccumulationTime time.Time `protobuf:"bytes,2,opt,name=previous_accumulation_time,json=previousAccumulationTime,proto3,stdtime" json:"previous_accumulation_time"`
@ -66,6 +68,48 @@ func (m *AccumulationTime) XXX_DiscardUnknown() {
var xxx_messageInfo_AccumulationTime proto.InternalMessageInfo
// AccrualTime stores the previous reward distribution time and its
// corresponding collateral type and claim type. This is the new version of
// AccumulationTime that is used for the new claim types.
type AccrualTime struct {
ClaimType ClaimType `protobuf:"varint,1,opt,name=claim_type,json=claimType,proto3,enum=kava.incentive.v1beta1.ClaimType" json:"claim_type,omitempty"`
CollateralType string `protobuf:"bytes,2,opt,name=collateral_type,json=collateralType,proto3" json:"collateral_type,omitempty"`
PreviousAccumulationTime time.Time `protobuf:"bytes,3,opt,name=previous_accumulation_time,json=previousAccumulationTime,proto3,stdtime" json:"previous_accumulation_time"`
}
func (m *AccrualTime) Reset() { *m = AccrualTime{} }
func (m *AccrualTime) String() string { return proto.CompactTextString(m) }
func (*AccrualTime) ProtoMessage() {}
func (*AccrualTime) Descriptor() ([]byte, []int) {
return fileDescriptor_8b76737885d05afd, []int{1}
}
func (m *AccrualTime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *AccrualTime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_AccrualTime.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *AccrualTime) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccrualTime.Merge(m, src)
}
func (m *AccrualTime) XXX_Size() int {
return m.Size()
}
func (m *AccrualTime) XXX_DiscardUnknown() {
xxx_messageInfo_AccrualTime.DiscardUnknown(m)
}
var xxx_messageInfo_AccrualTime proto.InternalMessageInfo
// GenesisRewardState groups together the global state for a particular reward so it can be exported in genesis.
type GenesisRewardState struct {
AccumulationTimes AccumulationTimes `protobuf:"bytes,1,rep,name=accumulation_times,json=accumulationTimes,proto3,castrepeated=AccumulationTimes" json:"accumulation_times"`
@ -76,7 +120,7 @@ func (m *GenesisRewardState) Reset() { *m = GenesisRewardState{} }
func (m *GenesisRewardState) String() string { return proto.CompactTextString(m) }
func (*GenesisRewardState) ProtoMessage() {}
func (*GenesisRewardState) Descriptor() ([]byte, []int) {
return fileDescriptor_8b76737885d05afd, []int{1}
return fileDescriptor_8b76737885d05afd, []int{2}
}
func (m *GenesisRewardState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -122,13 +166,14 @@ type GenesisState struct {
EarnRewardState GenesisRewardState `protobuf:"bytes,13,opt,name=earn_reward_state,json=earnRewardState,proto3" json:"earn_reward_state"`
EarnClaims EarnClaims `protobuf:"bytes,14,rep,name=earn_claims,json=earnClaims,proto3,castrepeated=EarnClaims" json:"earn_claims"`
Claims Claims `protobuf:"bytes,15,rep,name=claims,proto3,castrepeated=Claims" json:"claims"`
AccrualTimes AccrualTimes `protobuf:"bytes,16,rep,name=accrual_times,json=accrualTimes,proto3,castrepeated=AccrualTimes" json:"accrual_times"`
}
func (m *GenesisState) Reset() { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage() {}
func (*GenesisState) Descriptor() ([]byte, []int) {
return fileDescriptor_8b76737885d05afd, []int{2}
return fileDescriptor_8b76737885d05afd, []int{3}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -159,6 +204,7 @@ var xxx_messageInfo_GenesisState proto.InternalMessageInfo
func init() {
proto.RegisterType((*AccumulationTime)(nil), "kava.incentive.v1beta1.AccumulationTime")
proto.RegisterType((*AccrualTime)(nil), "kava.incentive.v1beta1.AccrualTime")
proto.RegisterType((*GenesisRewardState)(nil), "kava.incentive.v1beta1.GenesisRewardState")
proto.RegisterType((*GenesisState)(nil), "kava.incentive.v1beta1.GenesisState")
}
@ -168,58 +214,63 @@ func init() {
}
var fileDescriptor_8b76737885d05afd = []byte{
// 803 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x4f, 0x3b, 0x45,
0x18, 0xee, 0x02, 0x56, 0x98, 0x42, 0x4b, 0xc7, 0x02, 0xb5, 0xc4, 0x2d, 0x02, 0xd1, 0x46, 0xe3,
0x6e, 0xa8, 0x57, 0x2f, 0xae, 0x10, 0x25, 0x91, 0x84, 0x6c, 0x91, 0x18, 0x63, 0xd2, 0xcc, 0x76,
0x87, 0x65, 0x74, 0xff, 0xb9, 0xb3, 0xdb, 0xd2, 0x9b, 0x47, 0x0f, 0x1e, 0xf8, 0x00, 0x26, 0xde,
0xfd, 0x24, 0x1c, 0x39, 0x7a, 0x02, 0x2d, 0x5f, 0xc4, 0xcc, 0x9f, 0x2d, 0xbb, 0x2d, 0x8b, 0xf9,
0xf5, 0x77, 0x9b, 0x7d, 0xe7, 0x79, 0x9f, 0xe7, 0x79, 0xe7, 0x7d, 0xa7, 0x53, 0x70, 0xf8, 0x33,
0x1a, 0x22, 0x9d, 0xf8, 0x03, 0xec, 0xc7, 0x64, 0x88, 0xf5, 0xe1, 0x91, 0x85, 0x63, 0x74, 0xa4,
0x3b, 0xd8, 0xc7, 0x94, 0x50, 0x2d, 0x8c, 0x82, 0x38, 0x80, 0xdb, 0x0c, 0xa5, 0x4d, 0x51, 0x9a,
0x44, 0xb5, 0x1a, 0x4e, 0xe0, 0x04, 0x1c, 0xa2, 0xb3, 0x95, 0x40, 0xb7, 0x0e, 0x0a, 0x38, 0x07,
0x2e, 0x22, 0x1e, 0xfd, 0x1f, 0x50, 0x88, 0x22, 0x34, 0x05, 0xb5, 0x9d, 0x20, 0x70, 0x5c, 0xac,
0xf3, 0x2f, 0x2b, 0xb9, 0xd2, 0x63, 0xe2, 0x61, 0x1a, 0x23, 0x2f, 0x14, 0x80, 0xfd, 0x3f, 0x15,
0xb0, 0xf9, 0xe5, 0x60, 0x90, 0x78, 0x89, 0x8b, 0x62, 0x12, 0xf8, 0x17, 0xc4, 0xc3, 0xf0, 0x63,
0x50, 0x1b, 0x04, 0xae, 0x8b, 0x62, 0x1c, 0x21, 0xb7, 0x1f, 0x8f, 0x43, 0xdc, 0x54, 0xf6, 0x94,
0xce, 0x9a, 0x59, 0x7d, 0x0e, 0x5f, 0x8c, 0x43, 0x0c, 0x2d, 0xd0, 0x0a, 0x23, 0x3c, 0x24, 0x41,
0x42, 0xfb, 0x28, 0xc3, 0xd2, 0x67, 0x32, 0xcd, 0xa5, 0x3d, 0xa5, 0x53, 0xe9, 0xb6, 0x34, 0xe1,
0x41, 0x4b, 0x3d, 0x68, 0x17, 0xa9, 0x07, 0x63, 0xf5, 0xee, 0xa1, 0x5d, 0xba, 0x7d, 0x6c, 0x2b,
0x66, 0x33, 0xe5, 0x99, 0x35, 0xb3, 0xff, 0xeb, 0x12, 0x80, 0x5f, 0x8b, 0xc3, 0x34, 0xf1, 0x08,
0x45, 0x76, 0x2f, 0x46, 0x31, 0x86, 0x11, 0x80, 0x73, 0x8a, 0xb4, 0xa9, 0xec, 0x2d, 0x77, 0x2a,
0xdd, 0x8e, 0xf6, 0xf2, 0x71, 0x6b, 0xb3, 0xe4, 0xc6, 0xfb, 0xcc, 0xc0, 0x5f, 0x8f, 0xed, 0xfa,
0xec, 0x0e, 0x35, 0xeb, 0x68, 0x36, 0x04, 0x87, 0xa0, 0xe1, 0x25, 0x6e, 0x4c, 0xfa, 0x11, 0x37,
0xd2, 0x27, 0xbe, 0x8d, 0x6f, 0x30, 0x6d, 0x2e, 0xbd, 0xae, 0x7a, 0xc6, 0x72, 0x84, 0xf7, 0x53,
0x96, 0x61, 0xb4, 0xa4, 0x2a, 0x9c, 0xdd, 0xc1, 0xd4, 0x84, 0xde, 0x5c, 0x6c, 0xff, 0xf7, 0x75,
0xb0, 0x2e, 0x8f, 0x40, 0x14, 0xff, 0x05, 0x28, 0x8b, 0x36, 0xf3, 0xbe, 0x54, 0xba, 0x6a, 0x91,
0xf4, 0x39, 0x47, 0x19, 0x2b, 0x4c, 0xd0, 0x94, 0x39, 0x30, 0x00, 0xf5, 0x84, 0xda, 0x37, 0x69,
0x15, 0x94, 0x51, 0xca, 0x66, 0x7d, 0x52, 0x44, 0x34, 0xdf, 0x01, 0x63, 0x87, 0x91, 0x4e, 0x1e,
0xda, 0xb5, 0xef, 0x7a, 0xc7, 0xdf, 0x67, 0x36, 0xcc, 0x1a, 0x63, 0xcf, 0xf6, 0x8a, 0x80, 0xe6,
0x35, 0x57, 0x4a, 0xc2, 0xd0, 0x1d, 0xe7, 0x75, 0x97, 0xdf, 0x58, 0x57, 0x14, 0xb3, 0xc5, 0x18,
0x7b, 0x9c, 0xf0, 0x25, 0x29, 0x2b, 0x88, 0xa2, 0x60, 0x94, 0x97, 0x5a, 0x79, 0x1b, 0x29, 0x83,
0x13, 0x66, 0xa5, 0xae, 0xc0, 0xb6, 0x8d, 0x5d, 0xec, 0xa0, 0x38, 0x88, 0xf2, 0x42, 0xef, 0x2c,
0x28, 0xd4, 0x98, 0xf2, 0x65, 0x75, 0x7e, 0x04, 0x75, 0x3a, 0x42, 0x61, 0x5e, 0xa2, 0xbc, 0xa0,
0x44, 0x8d, 0x51, 0x65, 0xd9, 0x7f, 0x53, 0xc0, 0x7b, 0x7c, 0x1a, 0x3c, 0xe2, 0xc7, 0xc4, 0x77,
0xfa, 0xe2, 0x47, 0xa6, 0xf9, 0xee, 0xeb, 0x33, 0xcd, 0x7a, 0x7e, 0x26, 0x32, 0xbe, 0x62, 0x09,
0x86, 0x26, 0xa7, 0xa1, 0x3e, 0xbb, 0x43, 0xd9, 0xf5, 0x9a, 0x0b, 0x9a, 0x7c, 0x04, 0x73, 0x21,
0xf8, 0x87, 0x02, 0x54, 0xde, 0x3c, 0x97, 0xfc, 0x92, 0x10, 0x9b, 0xc4, 0xe3, 0x7e, 0x18, 0x05,
0x43, 0x62, 0xe3, 0x28, 0x75, 0xb5, 0xca, 0x5d, 0x75, 0x8b, 0x5c, 0x7d, 0x83, 0x22, 0xfb, 0xdb,
0x34, 0xf9, 0x5c, 0xe6, 0x0a, 0x7f, 0x07, 0xf2, 0xce, 0xed, 0x16, 0x63, 0xa8, 0xb9, 0x7b, 0x5d,
0xbc, 0x09, 0x7f, 0x02, 0x9b, 0xcf, 0xfd, 0x96, 0x7e, 0xd6, 0xb8, 0x9f, 0x8f, 0x8a, 0xfc, 0x1c,
0xa7, 0x78, 0xe1, 0x61, 0x47, 0x7a, 0xa8, 0xe5, 0xe3, 0xd4, 0xac, 0xd9, 0xf9, 0x00, 0xbc, 0x04,
0x15, 0xde, 0x73, 0x29, 0x03, 0xb8, 0xcc, 0x87, 0x45, 0x32, 0xbd, 0x11, 0x0a, 0x85, 0x02, 0x94,
0x0a, 0x60, 0x1a, 0xa2, 0x26, 0xa0, 0xd3, 0x35, 0xb4, 0x40, 0x83, 0xa2, 0x21, 0xf1, 0x1d, 0x9a,
0x1f, 0xa7, 0xca, 0x82, 0xe3, 0x04, 0x25, 0x5b, 0x76, 0xa2, 0x2c, 0x50, 0x4d, 0x35, 0xa4, 0xfd,
0x75, 0x6e, 0xff, 0xb0, 0xd0, 0xbe, 0x40, 0x8b, 0x0a, 0xb6, 0x64, 0x05, 0x1b, 0xd9, 0x28, 0x35,
0x37, 0x68, 0xf6, 0x93, 0xdd, 0x09, 0x8c, 0x22, 0x3f, 0x5f, 0xc4, 0xc6, 0xa2, 0x77, 0x82, 0x51,
0x65, 0x2b, 0xb8, 0x04, 0x15, 0xce, 0x2e, 0xed, 0x57, 0x5f, 0x3f, 0xfd, 0x13, 0x14, 0xf9, 0x33,
0xa7, 0x3f, 0x0d, 0x51, 0x13, 0xe0, 0xe9, 0x1a, 0x9e, 0x80, 0xb2, 0xa4, 0xac, 0x71, 0xca, 0x0f,
0x8a, 0x28, 0x05, 0x5d, 0x55, 0xd2, 0x95, 0x25, 0x95, 0x4c, 0x36, 0x4e, 0xef, 0xfe, 0x55, 0x4b,
0x77, 0x13, 0x55, 0xb9, 0x9f, 0xa8, 0xca, 0x3f, 0x13, 0x55, 0xb9, 0x7d, 0x52, 0x4b, 0xf7, 0x4f,
0x6a, 0xe9, 0xef, 0x27, 0xb5, 0xf4, 0xc3, 0xa7, 0x0e, 0x89, 0xaf, 0x13, 0x4b, 0x1b, 0x04, 0x9e,
0xce, 0xe8, 0x3f, 0x73, 0x91, 0x45, 0xf9, 0x4a, 0xbf, 0xc9, 0xfc, 0x5d, 0x60, 0xaf, 0x3a, 0xb5,
0xca, 0xfc, 0x51, 0xfe, 0xfc, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc0, 0xab, 0xe5, 0xd0, 0xc6,
0x08, 0x00, 0x00,
// 884 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x8f, 0xdb, 0x44,
0x14, 0x8e, 0xb3, 0x25, 0x74, 0x27, 0xd9, 0x64, 0x33, 0xa4, 0xad, 0x49, 0x85, 0xb3, 0xec, 0x56,
0xb0, 0x02, 0x61, 0xab, 0xe1, 0x86, 0x38, 0x50, 0xd3, 0x0a, 0x2a, 0x51, 0xa9, 0xf2, 0x2e, 0x15,
0x42, 0x88, 0x68, 0x6c, 0x4f, 0xbd, 0x03, 0xfe, 0xc5, 0x8c, 0x9d, 0xdd, 0xdc, 0x38, 0x72, 0xec,
0x1f, 0xc0, 0x8d, 0x1b, 0x7f, 0xc9, 0x1e, 0x7b, 0xe4, 0x80, 0xba, 0x90, 0xbd, 0xf2, 0x47, 0xa0,
0xf9, 0xe1, 0xac, 0x9d, 0xac, 0x83, 0x08, 0xdc, 0xc6, 0x6f, 0xbe, 0xf7, 0x7d, 0xdf, 0x9b, 0xf7,
0xec, 0x31, 0xb8, 0xf7, 0x3d, 0x9a, 0x22, 0x8b, 0xc4, 0x1e, 0x8e, 0x33, 0x32, 0xc5, 0xd6, 0xf4,
0xbe, 0x8b, 0x33, 0x74, 0xdf, 0x0a, 0x70, 0x8c, 0x19, 0x61, 0x66, 0x4a, 0x93, 0x2c, 0x81, 0xb7,
0x39, 0xca, 0x5c, 0xa0, 0x4c, 0x85, 0x1a, 0x0e, 0x82, 0x24, 0x48, 0x04, 0xc4, 0xe2, 0x2b, 0x89,
0x1e, 0x1e, 0xd4, 0x70, 0x7a, 0x21, 0x22, 0x11, 0xfb, 0x07, 0x50, 0x8a, 0x28, 0x5a, 0x80, 0x46,
0x41, 0x92, 0x04, 0x21, 0xb6, 0xc4, 0x93, 0x9b, 0x3f, 0xb7, 0x32, 0x12, 0x61, 0x96, 0xa1, 0x28,
0x95, 0x80, 0xfd, 0x5f, 0x34, 0xb0, 0xfb, 0xc0, 0xf3, 0xf2, 0x28, 0x0f, 0x51, 0x46, 0x92, 0xf8,
0x98, 0x44, 0x18, 0xbe, 0x0b, 0x7a, 0x5e, 0x12, 0x86, 0x28, 0xc3, 0x14, 0x85, 0x93, 0x6c, 0x96,
0x62, 0x5d, 0xdb, 0xd3, 0x0e, 0xb7, 0x9d, 0xee, 0x55, 0xf8, 0x78, 0x96, 0x62, 0xe8, 0x82, 0x61,
0x4a, 0xf1, 0x94, 0x24, 0x39, 0x9b, 0xa0, 0x12, 0xcb, 0x84, 0xcb, 0xe8, 0xcd, 0x3d, 0xed, 0xb0,
0x3d, 0x1e, 0x9a, 0xd2, 0x83, 0x59, 0x78, 0x30, 0x8f, 0x0b, 0x0f, 0xf6, 0xcd, 0xf3, 0x57, 0xa3,
0xc6, 0x8b, 0x8b, 0x91, 0xe6, 0xe8, 0x05, 0xcf, 0xb2, 0x99, 0x8f, 0x9a, 0xba, 0xb6, 0xff, 0xbb,
0x06, 0xda, 0x0f, 0x3c, 0x8f, 0xe6, 0x28, 0x14, 0x06, 0x3f, 0x01, 0x40, 0x9c, 0xc5, 0x95, 0xb7,
0xee, 0xf8, 0x6d, 0xf3, 0xfa, 0x33, 0x36, 0x3f, 0xe5, 0x48, 0x6e, 0xd7, 0xd9, 0xf6, 0x8a, 0xe5,
0x75, 0x25, 0x36, 0x37, 0x28, 0x71, 0xeb, 0xff, 0x28, 0x71, 0xff, 0xc7, 0x26, 0x80, 0x9f, 0xc9,
0x79, 0x71, 0xf0, 0x29, 0xa2, 0xfe, 0x51, 0x86, 0x32, 0x0c, 0x29, 0x80, 0x2b, 0x8a, 0x4c, 0xd7,
0xf6, 0xb6, 0x0e, 0xdb, 0xe3, 0xc3, 0xba, 0x6a, 0x97, 0xc9, 0xed, 0x37, 0xb9, 0x81, 0x5f, 0x2f,
0x46, 0xfd, 0xe5, 0x1d, 0xe6, 0xf4, 0xd1, 0x72, 0x08, 0x4e, 0xc1, 0x20, 0xca, 0xc3, 0x8c, 0x4c,
0xa8, 0x30, 0x32, 0x21, 0xb1, 0x8f, 0xcf, 0x30, 0xd3, 0x9b, 0xeb, 0x55, 0x9f, 0xf0, 0x1c, 0xe9,
0xfd, 0x31, 0xcf, 0xb0, 0x87, 0x4a, 0x15, 0x2e, 0xef, 0x60, 0xe6, 0xc0, 0x68, 0x25, 0xb6, 0xff,
0x57, 0x07, 0x74, 0xd4, 0x11, 0xc8, 0xe2, 0x3f, 0x06, 0x2d, 0x39, 0xc9, 0xa2, 0xbd, 0xed, 0xb1,
0x51, 0x27, 0xfd, 0x54, 0xa0, 0xec, 0x1b, 0x5c, 0xd0, 0x51, 0x39, 0x30, 0x01, 0xfd, 0x9c, 0xf9,
0x67, 0x45, 0x15, 0x8c, 0x53, 0xaa, 0x79, 0x7c, 0xaf, 0x8e, 0x68, 0xb5, 0x03, 0xf6, 0x1d, 0x4e,
0x3a, 0x7f, 0x35, 0xea, 0x7d, 0x79, 0xf4, 0xf0, 0xab, 0xd2, 0x86, 0xd3, 0xe3, 0xec, 0xe5, 0x5e,
0x11, 0xa0, 0x9f, 0x08, 0xa5, 0x3c, 0x4d, 0xc3, 0x59, 0x55, 0x77, 0xeb, 0x5f, 0xeb, 0xca, 0x62,
0x6e, 0x71, 0xc6, 0x23, 0x41, 0x78, 0x9d, 0x94, 0x9b, 0x50, 0x9a, 0x9c, 0x56, 0xa5, 0x6e, 0xfc,
0x17, 0x29, 0x5b, 0x10, 0x96, 0xa5, 0x9e, 0x83, 0xdb, 0x3e, 0x0e, 0x71, 0x80, 0xb2, 0x84, 0x56,
0x85, 0x5e, 0xdb, 0x50, 0x68, 0xb0, 0xe0, 0x2b, 0xeb, 0x7c, 0x03, 0xfa, 0xec, 0x14, 0xa5, 0x55,
0x89, 0xd6, 0x86, 0x12, 0x3d, 0x4e, 0x55, 0x66, 0xff, 0x49, 0x03, 0x6f, 0x88, 0x69, 0x88, 0x48,
0x9c, 0x91, 0x38, 0x98, 0xc8, 0xef, 0xa8, 0xfe, 0xfa, 0xfa, 0x99, 0xe6, 0x3d, 0x7f, 0x22, 0x33,
0xc4, 0x27, 0xc4, 0x36, 0xd5, 0x34, 0xf4, 0x97, 0x77, 0x18, 0x7f, 0xbd, 0x56, 0x82, 0x8e, 0x18,
0xc1, 0x4a, 0x08, 0xfe, 0xac, 0x01, 0x43, 0x34, 0x2f, 0x24, 0x3f, 0xe4, 0xc4, 0x27, 0xd9, 0x6c,
0x92, 0xd2, 0x64, 0x4a, 0x7c, 0x4c, 0x0b, 0x57, 0x37, 0x85, 0xab, 0x71, 0x9d, 0xab, 0xcf, 0x11,
0xf5, 0xbf, 0x28, 0x92, 0x9f, 0xaa, 0x5c, 0xe9, 0xef, 0x40, 0xbd, 0x73, 0x77, 0xeb, 0x31, 0xcc,
0xb9, 0x7b, 0x52, 0xbf, 0x09, 0xbf, 0x03, 0xbb, 0x57, 0xfd, 0x56, 0x7e, 0xb6, 0x85, 0x9f, 0x77,
0xea, 0xfc, 0x3c, 0x2c, 0xf0, 0xd2, 0xc3, 0x1d, 0xe5, 0xa1, 0x57, 0x8d, 0x33, 0xa7, 0xe7, 0x57,
0x03, 0xf0, 0x19, 0x68, 0x8b, 0x9e, 0x2b, 0x19, 0x20, 0x64, 0x6a, 0x3f, 0xe2, 0x47, 0xa7, 0x28,
0x95, 0x0a, 0x50, 0x29, 0x80, 0x45, 0x88, 0x39, 0x80, 0x2d, 0xd6, 0xd0, 0x05, 0x03, 0x86, 0xa6,
0x24, 0x0e, 0x58, 0x75, 0x9c, 0xda, 0x1b, 0x8e, 0x13, 0x54, 0x6c, 0xe5, 0x89, 0x72, 0x41, 0xb7,
0xd0, 0x50, 0xf6, 0x3b, 0xc2, 0xfe, 0xbd, 0x5a, 0xfb, 0x12, 0x2d, 0x2b, 0xb8, 0xa5, 0x2a, 0xd8,
0x29, 0x47, 0x99, 0xb3, 0xc3, 0xca, 0x8f, 0xfc, 0x9d, 0xc0, 0x88, 0xc6, 0xd5, 0x22, 0x76, 0x36,
0x7d, 0x27, 0x38, 0x55, 0xb9, 0x82, 0x67, 0xa0, 0x2d, 0xd8, 0x95, 0xfd, 0xee, 0xfa, 0xd3, 0x7f,
0x84, 0x68, 0xbc, 0x74, 0xfa, 0x8b, 0x10, 0x73, 0x00, 0x5e, 0xac, 0xe1, 0x23, 0xd0, 0x52, 0x94,
0x3d, 0x41, 0xf9, 0xd6, 0xda, 0x5b, 0xd9, 0xee, 0x2a, 0xba, 0x96, 0xa2, 0x52, 0xc9, 0xf0, 0x5b,
0xb0, 0x83, 0xe4, 0x7d, 0xaf, 0x6e, 0xbd, 0x5d, 0xc1, 0x76, 0xb0, 0xe6, 0xd6, 0x2b, 0x7e, 0x0e,
0xec, 0x81, 0xe2, 0xec, 0x94, 0x82, 0xcc, 0xe9, 0xa0, 0xd2, 0x93, 0xfd, 0xf8, 0xfc, 0x4f, 0xa3,
0x71, 0x3e, 0x37, 0xb4, 0x97, 0x73, 0x43, 0xfb, 0x63, 0x6e, 0x68, 0x2f, 0x2e, 0x8d, 0xc6, 0xcb,
0x4b, 0xa3, 0xf1, 0xdb, 0xa5, 0xd1, 0xf8, 0xfa, 0xfd, 0x80, 0x64, 0x27, 0xb9, 0x6b, 0x7a, 0x49,
0x64, 0x71, 0xc1, 0x0f, 0x42, 0xe4, 0x32, 0xb1, 0xb2, 0xce, 0x4a, 0x7f, 0x5c, 0xfc, 0xaf, 0x81,
0xb9, 0x2d, 0x71, 0xe9, 0x7f, 0xf8, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0d, 0xa4, 0x09, 0x98,
0x09, 0x0a, 0x00, 0x00,
}
func (m *AccumulationTime) Marshal() (dAtA []byte, err error) {
@ -260,6 +311,49 @@ func (m *AccumulationTime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *AccrualTime) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AccrualTime) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *AccrualTime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousAccumulationTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousAccumulationTime):])
if err2 != nil {
return 0, err2
}
i -= n2
i = encodeVarintGenesis(dAtA, i, uint64(n2))
i--
dAtA[i] = 0x1a
if len(m.CollateralType) > 0 {
i -= len(m.CollateralType)
copy(dAtA[i:], m.CollateralType)
i = encodeVarintGenesis(dAtA, i, uint64(len(m.CollateralType)))
i--
dAtA[i] = 0x12
}
if m.ClaimType != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.ClaimType))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *GenesisRewardState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -331,6 +425,22 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.AccrualTimes) > 0 {
for iNdEx := len(m.AccrualTimes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.AccrualTimes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x82
}
}
if len(m.Claims) > 0 {
for iNdEx := len(m.Claims) - 1; iNdEx >= 0; iNdEx-- {
{
@ -538,6 +648,24 @@ func (m *AccumulationTime) Size() (n int) {
return n
}
func (m *AccrualTime) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ClaimType != 0 {
n += 1 + sovGenesis(uint64(m.ClaimType))
}
l = len(m.CollateralType)
if l > 0 {
n += 1 + l + sovGenesis(uint64(l))
}
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousAccumulationTime)
n += 1 + l + sovGenesis(uint64(l))
return n
}
func (m *GenesisRewardState) Size() (n int) {
if m == nil {
return 0
@ -623,6 +751,12 @@ func (m *GenesisState) Size() (n int) {
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.AccrualTimes) > 0 {
for _, e := range m.AccrualTimes {
l = e.Size()
n += 2 + l + sovGenesis(uint64(l))
}
}
return n
}
@ -747,6 +881,140 @@ func (m *AccumulationTime) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *AccrualTime) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AccrualTime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AccrualTime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ClaimType", wireType)
}
m.ClaimType = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ClaimType |= ClaimType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CollateralType", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.CollateralType = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PreviousAccumulationTime", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.PreviousAccumulationTime, dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GenesisRewardState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -1396,6 +1664,40 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 16:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AccrualTimes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AccrualTimes = append(m.AccrualTimes, AccrualTime{})
if err := m.AccrualTimes[len(m.AccrualTimes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])

View File

@ -1,7 +1,6 @@
package types
import (
"strings"
"testing"
"time"
@ -135,6 +134,20 @@ func TestGenesisState_Validate(t *testing.T) {
contains: "claim owner cannot be empty",
},
},
{
name: "invalid accrual time",
genesis: GenesisState{
Params: DefaultParams(),
Claims: DefaultClaims,
AccrualTimes: AccrualTimes{
NewAccrualTime(CLAIM_TYPE_USDX_MINTING, "", time.Date(2020, 10, 15, 14, 0, 0, 0, time.UTC)),
},
},
errArgs: errArgs{
expectPass: false,
contains: "collateral type cannot be empty",
},
},
}
for _, tc := range testCases {
@ -144,7 +157,7 @@ func TestGenesisState_Validate(t *testing.T) {
require.NoError(t, err, tc.name)
} else {
require.Error(t, err, tc.name)
require.True(t, strings.Contains(err.Error(), tc.errArgs.contains))
require.Contains(t, err.Error(), tc.errArgs.contains)
}
})
}
@ -189,4 +202,76 @@ func TestGenesisAccumulationTimes_Validate(t *testing.T) {
}
}
func TestAccrualTimes_Validate(t *testing.T) {
testCases := []struct {
name string
gats AccrualTimes
wantErr bool
}{
{
name: "normal",
gats: AccrualTimes{
{
ClaimType: CLAIM_TYPE_USDX_MINTING,
CollateralType: "btcb",
PreviousAccumulationTime: normalAccumulationtime,
},
{
ClaimType: CLAIM_TYPE_USDX_MINTING,
CollateralType: "bnb",
PreviousAccumulationTime: normalAccumulationtime,
},
},
wantErr: false,
},
{
name: "empty",
gats: nil,
wantErr: false,
},
{
name: "empty collateral type",
gats: AccrualTimes{
{
ClaimType: CLAIM_TYPE_USDX_MINTING,
PreviousAccumulationTime: normalAccumulationtime,
},
},
wantErr: true,
},
{
name: "invalid claim type",
gats: AccrualTimes{
{
ClaimType: 10000000,
CollateralType: "btcb",
PreviousAccumulationTime: normalAccumulationtime,
},
},
wantErr: true,
},
{
name: "unspecified claim type",
gats: AccrualTimes{
{
ClaimType: CLAIM_TYPE_UNSPECIFIED,
CollateralType: "btcb",
PreviousAccumulationTime: normalAccumulationtime,
},
},
wantErr: true,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
err := tc.gats.Validate()
if tc.wantErr {
require.NotNil(t, err)
} else {
require.Nil(t, err)
}
})
}
}
var normalAccumulationtime = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)

View File

@ -1,6 +1,8 @@
package types
import "encoding/binary"
import (
"encoding/binary"
)
const (
// ModuleName The name that will be used throughout the module
@ -81,3 +83,8 @@ func GetRewardIndexesKeyPrefix(claimType ClaimType) []byte {
func GetPreviousRewardAccrualTimeKeyPrefix(claimType ClaimType) []byte {
return getKeyPrefix(PreviousRewardAccrualTimeKeyPrefix, claimType)
}
// GetKeyFromSourceID returns the store key for the given source ID.
func GetKeyFromSourceID(sourceID string) []byte {
return []byte(sourceID)
}