Add incentive claim state methods (#1375)

* Add Claim proto types

* Add new claim keys

* Add claim state method tests

* Add claims to genesis

* Re-add GetType for USDX claim

* Add doc comments to key methods

* Add Claim validate test

* Update claimType to BigEndian binary encoding

docs/core/proto-docs.md

@@ -4832,6 +4832,7 @@ GenesisState is the state that must be provided at genesis.
 | `savings_claims` | [SavingsClaim](#kava.incentive.v1beta1.SavingsClaim) | repeated |  |
 | `earn_reward_state` | [GenesisRewardState](#kava.incentive.v1beta1.GenesisRewardState) |  |  |
 | `earn_claims` | [EarnClaim](#kava.incentive.v1beta1.EarnClaim) | repeated |  |
+| `claims` | [Claim](#kava.incentive.v1beta1.Claim) | repeated |  |
 
 
 

proto/kava/incentive/v1beta1/genesis.proto

@@ -64,4 +64,6 @@ message GenesisState {
   GenesisRewardState earn_reward_state = 13 [(gogoproto.nullable) = false];
 
   repeated EarnClaim earn_claims = 14 [(gogoproto.castrepeated) = "EarnClaims", (gogoproto.nullable) = false];
+
+  repeated Claim claims = 15 [(gogoproto.castrepeated) = "Claims", (gogoproto.nullable) = false];
 }

x/incentive/genesis.go

@@ -44,6 +44,11 @@ func InitGenesis(
 
 	k.SetParams(ctx, gs.Params)
 
+	// Set Claims of all types
+	for _, claim := range gs.Claims {
+		k.SetClaim(ctx, claim)
+	}
+
 	// USDX Minting
 	for _, claim := range gs.USDXMintingClaims {
 		k.SetUSDXMintingClaim(ctx, claim)
@@ -146,6 +151,8 @@ func InitGenesis(
 func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
 	params := k.GetParams(ctx)
 
+	claims := k.GetAllClaims(ctx)
+
 	usdxClaims := k.GetAllUSDXMintingClaims(ctx)
 	usdxRewardState := getUSDXMintingGenesisRewardState(ctx, k)
 
@@ -170,7 +177,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
 		// Reward states
 		usdxRewardState, hardSupplyRewardState, hardBorrowRewardState, delegatorRewardState, swapRewardState, savingsRewardState, earnRewardState,
 		// Claims
-		usdxClaims, hardClaims, delegatorClaims, swapClaims, savingsClaims, earnClaims,
+		claims, usdxClaims, hardClaims, delegatorClaims, swapClaims, savingsClaims, earnClaims,
 	)
 }
 

x/incentive/genesis_test.go

@@ -102,6 +102,7 @@ func (suite *GenesisTestSuite) SetupTest() {
 		types.DefaultGenesisRewardState,
 		types.DefaultGenesisRewardState,
 		types.DefaultGenesisRewardState,
+		types.DefaultClaims,
 		types.DefaultUSDXClaims,
 		types.DefaultHardClaims,
 		types.DefaultDelegatorClaims,
@@ -219,6 +220,14 @@ func (suite *GenesisTestSuite) TestExportedGenesisMatchesImported() {
 				types.NewMultiRewardIndex("usdx", types.RewardIndexes{{CollateralType: "usdx", RewardFactor: d("0.2")}}),
 			},
 		),
+		types.Claims{
+			types.NewClaim(
+				types.CLAIM_TYPE_USDX_MINTING,
+				suite.addrs[3],
+				nil,
+				types.MultiRewardIndexes{{CollateralType: "btcb/usdx", RewardIndexes: types.RewardIndexes{{CollateralType: "swap", RewardFactor: d("0.0")}}}},
+			),
+		},
 		types.USDXMintingClaims{
 			types.NewUSDXMintingClaim(
 				suite.addrs[0],

x/incentive/keeper/keeper.go

@@ -881,3 +881,103 @@ func (k Keeper) IterateEarnRewardAccrualTimes(ctx sdk.Context, cb func(string, t
 		}
 	}
 }
+
+// -----------------------------------------------------------------------------
+// New deduplicated methods
+
+// GetClaim returns the claim in the store corresponding the the owner and
+// claimType, and a boolean for if the claim was found
+func (k Keeper) GetClaim(
+	ctx sdk.Context,
+	claimType types.ClaimType,
+	addr sdk.AccAddress,
+) (types.Claim, bool) {
+	store := prefix.NewStore(ctx.KVStore(k.key), types.GetClaimKeyPrefix(claimType))
+	bz := store.Get(addr)
+	if bz == nil {
+		return types.Claim{}, false
+	}
+	var c types.Claim
+	k.cdc.MustUnmarshal(bz, &c)
+	return c, true
+}
+
+// SetClaim sets the claim in the store corresponding to the owner and claimType
+func (k Keeper) SetClaim(
+	ctx sdk.Context,
+	c types.Claim,
+) {
+	store := prefix.NewStore(ctx.KVStore(k.key), types.GetClaimKeyPrefix(c.Type))
+	bz := k.cdc.MustMarshal(&c)
+	store.Set(c.Owner, bz)
+}
+
+// DeleteClaim deletes the claim in the store corresponding to the owner and claimType
+func (k Keeper) DeleteClaim(
+	ctx sdk.Context,
+	claimType types.ClaimType,
+	owner sdk.AccAddress,
+) {
+	store := prefix.NewStore(ctx.KVStore(k.key), types.GetClaimKeyPrefix(claimType))
+	store.Delete(owner)
+}
+
+// IterateClaims iterates over all claim objects in the store of a given
+// claimType and preforms a callback function
+func (k Keeper) IterateClaims(
+	ctx sdk.Context,
+	claimType types.ClaimType,
+	cb func(c types.Claim) (stop bool),
+) {
+	iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.key), types.GetClaimKeyPrefix(claimType))
+	defer iterator.Close()
+	for ; iterator.Valid(); iterator.Next() {
+		var c types.Claim
+		k.cdc.MustUnmarshal(iterator.Value(), &c)
+		if cb(c) {
+			break
+		}
+	}
+}
+
+// GetClaims returns all Claim objects in the store of a given claimType
+func (k Keeper) GetClaims(
+	ctx sdk.Context,
+	claimType types.ClaimType,
+) types.Claims {
+	var cs types.Claims
+	k.IterateClaims(ctx, claimType, func(c types.Claim) (stop bool) {
+		cs = append(cs, c)
+		return false
+	})
+
+	return cs
+}
+
+// IterateAllClaims iterates over all claim objects of any claimType in the
+// store and preforms a callback function
+func (k Keeper) IterateAllClaims(
+	ctx sdk.Context,
+	cb func(c types.Claim) (stop bool),
+) {
+	iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.key), types.ClaimKeyPrefix)
+	defer iterator.Close()
+	for ; iterator.Valid(); iterator.Next() {
+		var c types.Claim
+		k.cdc.MustUnmarshal(iterator.Value(), &c)
+		if cb(c) {
+			break
+		}
+	}
+}
+
+// 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) {
+		cs = append(cs, c)
+		return false
+	})
+
+	return cs
+}

x/incentive/keeper/keeper_state_test.go

@@ -0,0 +1,87 @@
+package keeper_test
+
+import (
+	"github.com/kava-labs/kava/x/incentive/types"
+)
+
+func (suite *KeeperTestSuite) TestGetSetDeleteClaims() {
+	suite.SetupApp()
+
+	for claimTypeName, claimTypeValue := range types.ClaimType_value {
+		suite.Run(claimTypeName, func() {
+			claimType := types.ClaimType(claimTypeValue)
+
+			c := types.NewClaim(
+				claimType,
+				suite.addrs[0],
+				arbitraryCoins(),
+				nonEmptyMultiRewardIndexes,
+			)
+
+			_, found := suite.keeper.GetClaim(suite.ctx, claimType, suite.addrs[0])
+			suite.Require().False(found)
+
+			suite.Require().NotPanics(func() {
+				suite.keeper.SetClaim(suite.ctx, c)
+			})
+			testC, found := suite.keeper.GetClaim(suite.ctx, claimType, suite.addrs[0])
+			suite.Require().True(found)
+			suite.Require().Equal(c, testC)
+
+			// Check that other claim types do not exist for the same address
+			for otherClaimTypeName, otherClaimTypeValue := range types.ClaimType_value {
+				// Skip the current claim type
+				if otherClaimTypeValue == claimTypeValue {
+					continue
+				}
+
+				otherClaimType := types.ClaimType(otherClaimTypeValue)
+				_, found := suite.keeper.GetClaim(suite.ctx, otherClaimType, suite.addrs[0])
+				suite.Require().False(found, "claim type %s should not exist", otherClaimTypeName)
+			}
+
+			suite.Require().NotPanics(func() {
+				suite.keeper.DeleteClaim(suite.ctx, claimType, suite.addrs[0])
+			})
+			_, found = suite.keeper.GetClaim(suite.ctx, claimType, suite.addrs[0])
+			suite.Require().False(found)
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestIterateClaims() {
+	suite.SetupApp()
+	var claims types.Claims
+
+	// Add 2 of each type of claim
+	for _, claimTypeValue := range types.ClaimType_value {
+		c := types.Claims{
+			types.NewClaim(types.ClaimType(claimTypeValue), suite.addrs[0], arbitraryCoins(), nonEmptyMultiRewardIndexes),
+			types.NewClaim(types.ClaimType(claimTypeValue), suite.addrs[1], nil, nil),
+		}
+		claims = append(claims, c...)
+	}
+
+	for _, claim := range claims {
+		suite.keeper.SetClaim(suite.ctx, claim)
+	}
+
+	for _, claimTypeValue := range types.ClaimType_value {
+		claimType := types.ClaimType(claimTypeValue)
+
+		// Claims of specific claim type only should be returned
+		claims := suite.keeper.GetClaims(suite.ctx, claimType)
+		suite.Require().Len(claims, 2)
+		suite.Require().Equalf(
+			claims, types.Claims{
+				types.NewClaim(claimType, suite.addrs[0], arbitraryCoins(), nonEmptyMultiRewardIndexes),
+				types.NewClaim(claimType, suite.addrs[1], nil, nil),
+			},
+			"GetClaims(%s) should only return claims of those type", claimType,
+		)
+	}
+
+	allClaims := suite.keeper.GetAllClaims(suite.ctx)
+	suite.Require().Len(allClaims, len(claims))
+	suite.Require().ElementsMatch(allClaims, claims, "GetAllClaims() should return claims of all types")
+}

x/incentive/types/claims.go

@@ -163,6 +163,20 @@ func (cs USDXMintingClaims) Validate() error {
 	return nil
 }
 
+// Claims defines a slice of Claims
+type Claims []Claim
+
+// Validate checks if all the claims are valid.
+func (cs Claims) Validate() error {
+	for _, c := range cs {
+		if err := c.Validate(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // NewHardLiquidityProviderClaim returns a new HardLiquidityProviderClaim
 func NewHardLiquidityProviderClaim(owner sdk.AccAddress, rewards sdk.Coins,
 	supplyRewardIndexes, borrowRewardIndexes MultiRewardIndexes,

x/incentive/types/claims_test.go

@@ -21,6 +21,59 @@ func cs(coins ...sdk.Coin) sdk.Coins { return sdk.NewCoins(coins...) }
 func TestClaims_Validate(t *testing.T) {
 	owner := sdk.AccAddress(crypto.AddressHash([]byte("KavaTestUser1")))
 
+	t.Run("Claims", func(t *testing.T) {
+		validRewardIndexes := RewardIndexes{}.With("ukava", d("0.002"))
+		validMultiRewardIndexes := MultiRewardIndexes{}.With("ukava", validRewardIndexes)
+		invalidRewardIndexes := RewardIndexes{}.With("ukava", d("-0.002"))
+		invalidMultiRewardIndexes := MultiRewardIndexes{}.With("ukava", invalidRewardIndexes)
+
+		testCases := []struct {
+			name    string
+			claims  Claims
+			expPass bool
+		}{
+			{
+				name: "valid",
+				claims: Claims{
+					NewClaim(CLAIM_TYPE_USDX_MINTING, owner, cs(c("bnb", 1)), validMultiRewardIndexes),
+				},
+				expPass: true,
+			},
+			{
+				name: "invalid owner",
+				claims: Claims{
+					NewClaim(CLAIM_TYPE_USDX_MINTING, nil, cs(c("bnb", 1)), validMultiRewardIndexes),
+				},
+				expPass: false,
+			},
+			{
+				name: "invalid reward",
+				claims: Claims{
+					NewClaim(CLAIM_TYPE_USDX_MINTING, owner, sdk.Coins{sdk.Coin{Denom: "invalid😫"}}, validMultiRewardIndexes),
+				},
+				expPass: false,
+			},
+			{
+				name: "invalid indexes",
+				claims: Claims{
+					NewClaim(CLAIM_TYPE_USDX_MINTING, nil, cs(c("bnb", 1)), invalidMultiRewardIndexes),
+				},
+				expPass: false,
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				err := tc.claims.Validate()
+				if tc.expPass {
+					require.NoError(t, err)
+				} else {
+					require.Error(t, err)
+				}
+			})
+		}
+	})
+
 	t.Run("USDXMintingClaims", func(t *testing.T) {
 		testCases := []struct {
 			name    string

x/incentive/types/genesis.go

@@ -6,6 +6,7 @@ import (
 )
 
 var (
+	DefaultClaims             = Claims{}
 	DefaultUSDXClaims         = USDXMintingClaims{}
 	DefaultHardClaims         = HardLiquidityProviderClaims{}
 	DefaultDelegatorClaims    = DelegatorClaims{}
@@ -22,7 +23,8 @@ var (
 func NewGenesisState(
 	params Params,
 	usdxState, hardSupplyState, hardBorrowState, delegatorState, swapState, savingsState, earnState GenesisRewardState,
-	c USDXMintingClaims, hc HardLiquidityProviderClaims, dc DelegatorClaims, sc SwapClaims, savingsc SavingsClaims,
+	c Claims,
+	uc USDXMintingClaims, hc HardLiquidityProviderClaims, dc DelegatorClaims, sc SwapClaims, savingsc SavingsClaims,
 	earnc EarnClaims,
 ) GenesisState {
 	return GenesisState{
@@ -36,7 +38,9 @@ func NewGenesisState(
 		SavingsRewardState:    savingsState,
 		EarnRewardState:       earnState,
 
-		USDXMintingClaims:           c,
+		// Claims of all types
+		Claims:                      c,
+		USDXMintingClaims:           uc,
 		HardLiquidityProviderClaims: hc,
 		DelegatorClaims:             dc,
 		SwapClaims:                  sc,
@@ -56,6 +60,7 @@ func DefaultGenesisState() GenesisState {
 		SwapRewardState:             DefaultGenesisRewardState,
 		SavingsRewardState:          DefaultGenesisRewardState,
 		EarnRewardState:             DefaultGenesisRewardState,
+		Claims:                      DefaultClaims,
 		USDXMintingClaims:           DefaultUSDXClaims,
 		HardLiquidityProviderClaims: DefaultHardClaims,
 		DelegatorClaims:             DefaultDelegatorClaims,
@@ -94,6 +99,10 @@ 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
 	}

x/incentive/types/genesis.pb.go

@@ -121,6 +121,7 @@ type GenesisState struct {
 	SavingsClaims               SavingsClaims               `protobuf:"bytes,12,rep,name=savings_claims,json=savingsClaims,proto3,castrepeated=SavingsClaims" json:"savings_claims"`
 	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"`
 }
 
 func (m *GenesisState) Reset()         { *m = GenesisState{} }
@@ -167,57 +168,58 @@ func init() {
 }
 
 var fileDescriptor_8b76737885d05afd = []byte{
-	// 785 bytes of a gzipped FileDescriptorProto
+	// 803 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x4f, 0xdb, 0x48,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x4f, 0x3b, 0x45,
-	0x14, 0xc7, 0x63, 0x60, 0x59, 0x98, 0x00, 0x21, 0xb3, 0x01, 0xb2, 0x41, 0x72, 0x58, 0x40, 0xbb,
+	0x18, 0xee, 0x02, 0x56, 0x98, 0x42, 0x4b, 0xc7, 0x02, 0xb5, 0xc4, 0x2d, 0x02, 0xd1, 0x46, 0xe3,
-	0xd1, 0x56, 0xb5, 0x45, 0x7a, 0xed, 0xa5, 0x2e, 0x55, 0x8b, 0x54, 0x24, 0xe4, 0x50, 0x54, 0x55,
+	0x6e, 0xa8, 0x57, 0x2f, 0xae, 0x10, 0x25, 0x91, 0x84, 0x6c, 0x91, 0x18, 0x63, 0xd2, 0xcc, 0x76,
-	0x95, 0xa2, 0x71, 0x3c, 0x98, 0x69, 0xfd, 0xab, 0x1e, 0x3b, 0x21, 0xb7, 0x1e, 0x7b, 0xe4, 0x0f,
+	0x87, 0x65, 0x74, 0xff, 0xb9, 0xb3, 0xdb, 0xd2, 0x9b, 0x47, 0x0f, 0x1e, 0xf8, 0x00, 0x26, 0xde,
-	0xa8, 0xd4, 0x7b, 0xff, 0x8f, 0x4a, 0x1c, 0x39, 0xf6, 0x04, 0x6d, 0xf8, 0x47, 0xaa, 0x19, 0x8f,
+	0xfd, 0x24, 0x1c, 0x39, 0x7a, 0x02, 0x2d, 0x5f, 0xc4, 0xcc, 0x9f, 0x2d, 0xbb, 0x2d, 0x8b, 0xf9,
-	0x83, 0x9d, 0x60, 0xaa, 0xa6, 0xb7, 0xc9, 0x9b, 0x37, 0xdf, 0xcf, 0xf7, 0xcd, 0x7b, 0x13, 0x83,
+	0xf5, 0x77, 0x9b, 0x7d, 0xe7, 0x79, 0x9f, 0xe7, 0x79, 0xe7, 0x7d, 0xa7, 0x53, 0x70, 0xf8, 0x33,
-	0xed, 0xb7, 0xa8, 0x8b, 0x54, 0xe2, 0x76, 0xb0, 0x1b, 0x92, 0x2e, 0x56, 0xbb, 0x3b, 0x06, 0x0e,
+	0x1a, 0x22, 0x9d, 0xf8, 0x03, 0xec, 0xc7, 0x64, 0x88, 0xf5, 0xe1, 0x91, 0x85, 0x63, 0x74, 0xa4,
-	0xd1, 0x8e, 0x6a, 0x61, 0x17, 0x53, 0x42, 0x15, 0x3f, 0xf0, 0x42, 0x0f, 0xae, 0xb2, 0x2c, 0x65,
+	0x3b, 0xd8, 0xc7, 0x94, 0x50, 0x2d, 0x8c, 0x82, 0x38, 0x80, 0xdb, 0x0c, 0xa5, 0x4d, 0x51, 0x9a,
-	0x98, 0xa5, 0x88, 0xac, 0x5a, 0xc5, 0xf2, 0x2c, 0x8f, 0xa7, 0xa8, 0x6c, 0x15, 0x67, 0xd7, 0xb6,
+	0x44, 0xb5, 0x1a, 0x4e, 0xe0, 0x04, 0x1c, 0xa2, 0xb3, 0x95, 0x40, 0xb7, 0x0e, 0x0a, 0x38, 0x07,
-	0x72, 0x34, 0x3b, 0x36, 0x22, 0x0e, 0xfd, 0x49, 0x92, 0x8f, 0x02, 0x34, 0x4c, 0xaa, 0x5b, 0x9e,
+	0x2e, 0x22, 0x1e, 0xfd, 0x1f, 0x50, 0x88, 0x22, 0x34, 0x05, 0xb5, 0x9d, 0x20, 0x70, 0x5c, 0xac,
-	0x67, 0xd9, 0x58, 0xe5, 0xbf, 0x8c, 0xe8, 0x58, 0x0d, 0x89, 0x83, 0x69, 0x88, 0x1c, 0x3f, 0x4e,
+	0xf3, 0x2f, 0x2b, 0xb9, 0xd2, 0x63, 0xe2, 0x61, 0x1a, 0x23, 0x2f, 0x14, 0x80, 0xfd, 0x3f, 0x15,
-	0xd8, 0xfc, 0x24, 0x81, 0xe5, 0x47, 0x9d, 0x4e, 0xe4, 0x44, 0x36, 0x0a, 0x89, 0xe7, 0x1e, 0x12,
+	0xb0, 0xf9, 0xe5, 0x60, 0x90, 0x78, 0x89, 0x8b, 0x62, 0x12, 0xf8, 0x17, 0xc4, 0xc3, 0xf0, 0x63,
-	0x07, 0xc3, 0xff, 0x40, 0xa9, 0xe3, 0xd9, 0x36, 0x0a, 0x71, 0x80, 0xec, 0x76, 0xd8, 0xf7, 0x71,
+	0x50, 0x1b, 0x04, 0xae, 0x8b, 0x62, 0x1c, 0x21, 0xb7, 0x1f, 0x8f, 0x43, 0xdc, 0x54, 0xf6, 0x94,
-	0x55, 0xda, 0x90, 0x1a, 0xf3, 0xfa, 0xd2, 0x4d, 0xf8, 0xb0, 0xef, 0x63, 0x68, 0x80, 0x9a, 0x1f,
+	0xce, 0x9a, 0x59, 0x7d, 0x0e, 0x5f, 0x8c, 0x43, 0x0c, 0x2d, 0xd0, 0x0a, 0x23, 0x3c, 0x24, 0x41,
-	0xe0, 0x2e, 0xf1, 0x22, 0xda, 0x46, 0x29, 0x95, 0x36, 0xc3, 0x54, 0xa7, 0x36, 0xa4, 0x46, 0xb1,
+	0x42, 0xfb, 0x28, 0xc3, 0xd2, 0x67, 0x32, 0xcd, 0xa5, 0x3d, 0xa5, 0x53, 0xe9, 0xb6, 0x34, 0xe1,
-	0x59, 0x53, 0x62, 0x0f, 0x4a, 0xe2, 0x41, 0x39, 0x4c, 0x3c, 0x68, 0x73, 0xe7, 0x97, 0xf5, 0xc2,
+	0x41, 0x4b, 0x3d, 0x68, 0x17, 0xa9, 0x07, 0x63, 0xf5, 0xee, 0xa1, 0x5d, 0xba, 0x7d, 0x6c, 0x2b,
-	0xd9, 0x55, 0x5d, 0xd2, 0xab, 0x89, 0xce, 0xa8, 0x99, 0xcd, 0xf7, 0x53, 0x00, 0x3e, 0x8d, 0x2f,
+	0x66, 0x33, 0xe5, 0x99, 0x35, 0xb3, 0xff, 0xeb, 0x12, 0x80, 0x5f, 0x8b, 0xc3, 0x34, 0xf1, 0x08,
-	0x53, 0xc7, 0x3d, 0x14, 0x98, 0xad, 0x10, 0x85, 0x18, 0x06, 0x00, 0x8e, 0x11, 0x69, 0x55, 0xda,
+	0x45, 0x76, 0x2f, 0x46, 0x31, 0x86, 0x11, 0x80, 0x73, 0x8a, 0xb4, 0xa9, 0xec, 0x2d, 0x77, 0x2a,
-	0x98, 0x6e, 0x14, 0x9b, 0x0d, 0xe5, 0xf6, 0xeb, 0x56, 0x46, 0xc5, 0xb5, 0xbf, 0x99, 0x81, 0xcf,
+	0xdd, 0x8e, 0xf6, 0xf2, 0x71, 0x6b, 0xb3, 0xe4, 0xc6, 0xfb, 0xcc, 0xc0, 0x5f, 0x8f, 0xed, 0xfa,
-	0x57, 0xf5, 0xf2, 0xe8, 0x0e, 0xd5, 0xcb, 0x68, 0x34, 0x04, 0xbb, 0xa0, 0xe2, 0x44, 0x76, 0x48,
+	0xec, 0x0e, 0x35, 0xeb, 0x68, 0x36, 0x04, 0x87, 0xa0, 0xe1, 0x25, 0x6e, 0x4c, 0xfa, 0x11, 0x37,
-	0xda, 0x01, 0x37, 0xd2, 0x26, 0xae, 0x89, 0x4f, 0x31, 0xad, 0x4e, 0xdd, 0x4d, 0xdd, 0x67, 0x67,
+	0xd2, 0x27, 0xbe, 0x8d, 0x6f, 0x30, 0x6d, 0x2e, 0xbd, 0xae, 0x7a, 0xc6, 0x72, 0x84, 0xf7, 0x53,
-	0x62, 0xef, 0x7b, 0xec, 0x84, 0x56, 0x13, 0x54, 0x38, 0xba, 0x83, 0xa9, 0x0e, 0x9d, 0xb1, 0xd8,
+	0x96, 0x61, 0xb4, 0xa4, 0x2a, 0x9c, 0xdd, 0xc1, 0xd4, 0x84, 0xde, 0x5c, 0x6c, 0xff, 0xf7, 0x75,
-	0xe6, 0x97, 0x22, 0x58, 0x10, 0x57, 0x10, 0x17, 0xff, 0x10, 0xcc, 0xc6, 0x6d, 0xe6, 0x7d, 0x29,
+	0xb0, 0x2e, 0x8f, 0x40, 0x14, 0xff, 0x05, 0x28, 0x8b, 0x36, 0xf3, 0xbe, 0x54, 0xba, 0x6a, 0x91,
-	0x36, 0xe5, 0x3c, 0xf4, 0x01, 0xcf, 0xd2, 0x66, 0x18, 0x50, 0x17, 0x67, 0xa0, 0x07, 0xca, 0x11,
+	0xf4, 0x39, 0x47, 0x19, 0x2b, 0x4c, 0xd0, 0x94, 0x39, 0x30, 0x00, 0xf5, 0x84, 0xda, 0x37, 0x69,
-	0x35, 0x4f, 0x93, 0x2a, 0x28, 0x93, 0x14, 0xcd, 0xfa, 0x3f, 0x4f, 0x68, 0xbc, 0x03, 0xda, 0x1a,
+	0x15, 0x94, 0x51, 0xca, 0x66, 0x7d, 0x52, 0x44, 0x34, 0xdf, 0x01, 0x63, 0x87, 0x91, 0x4e, 0x1e,
-	0x13, 0x1d, 0x5c, 0xd6, 0x4b, 0x2f, 0x5a, 0xbb, 0x2f, 0x53, 0x1b, 0x7a, 0x89, 0xa9, 0xa7, 0x7b,
+	0xda, 0xb5, 0xef, 0x7a, 0xc7, 0xdf, 0x67, 0x36, 0xcc, 0x1a, 0x63, 0xcf, 0xf6, 0x8a, 0x80, 0xe6,
-	0x45, 0x40, 0xf5, 0x84, 0x93, 0x22, 0xdf, 0xb7, 0xfb, 0x59, 0xee, 0xf4, 0x2f, 0x73, 0xe3, 0x62,
+	0x35, 0x57, 0x4a, 0xc2, 0xd0, 0x1d, 0xe7, 0x75, 0x97, 0xdf, 0x58, 0x57, 0x14, 0xb3, 0xc5, 0x18,
-	0x56, 0x98, 0x62, 0x8b, 0x0b, 0xde, 0x86, 0x32, 0xbc, 0x20, 0xf0, 0x7a, 0x59, 0xd4, 0xcc, 0xef,
+	0x7b, 0x9c, 0xf0, 0x25, 0x29, 0x2b, 0x88, 0xa2, 0x60, 0x94, 0x97, 0x5a, 0x79, 0x1b, 0x29, 0x83,
-	0xa0, 0x34, 0x2e, 0x98, 0x46, 0x1d, 0x83, 0x55, 0x13, 0xdb, 0xd8, 0x42, 0xa1, 0x17, 0x64, 0x41,
+	0x13, 0x66, 0xa5, 0xae, 0xc0, 0xb6, 0x8d, 0x5d, 0xec, 0xa0, 0x38, 0x88, 0xf2, 0x42, 0xef, 0x2c,
-	0x7f, 0x4c, 0x08, 0xaa, 0x0c, 0xf5, 0xd2, 0x9c, 0xd7, 0xa0, 0x4c, 0x7b, 0xc8, 0xcf, 0x22, 0x66,
+	0x28, 0xd4, 0x98, 0xf2, 0x65, 0x75, 0x7e, 0x04, 0x75, 0x3a, 0x42, 0x61, 0x5e, 0xa2, 0xbc, 0xa0,
-	0x27, 0x44, 0x94, 0x98, 0x54, 0x5a, 0xfd, 0x83, 0x04, 0xfe, 0xe2, 0xd3, 0xe0, 0x10, 0x37, 0x24,
+	0x44, 0x8d, 0x51, 0x65, 0xd9, 0x7f, 0x53, 0xc0, 0x7b, 0x7c, 0x1a, 0x3c, 0xe2, 0xc7, 0xc4, 0x77,
-	0xae, 0xd5, 0x8e, 0xff, 0x64, 0xaa, 0x7f, 0xde, 0x3d, 0xd3, 0xac, 0xe7, 0xfb, 0xf1, 0x89, 0xc7,
+	0xfa, 0xe2, 0x47, 0xa6, 0xf9, 0xee, 0xeb, 0x33, 0xcd, 0x7a, 0x7e, 0x26, 0x32, 0xbe, 0x62, 0x09,
-	0xec, 0x80, 0xa6, 0x88, 0x69, 0x28, 0x8f, 0xee, 0x50, 0xf6, 0xbc, 0xc6, 0x82, 0x3a, 0x1f, 0xc1,
+	0x86, 0x26, 0xa7, 0xa1, 0x3e, 0xbb, 0x43, 0xd9, 0xf5, 0x9a, 0x0b, 0x9a, 0x7c, 0x04, 0x73, 0x21,
-	0x4c, 0x08, 0x7e, 0x94, 0x80, 0xcc, 0x9b, 0x67, 0x93, 0x77, 0x11, 0x31, 0x49, 0xd8, 0x6f, 0xfb,
+	0xf8, 0x87, 0x02, 0x54, 0xde, 0x3c, 0x97, 0xfc, 0x92, 0x10, 0x9b, 0xc4, 0xe3, 0x7e, 0x18, 0x05,
-	0x81, 0xd7, 0x25, 0x26, 0x0e, 0x12, 0x57, 0x73, 0xdc, 0x55, 0x33, 0xcf, 0xd5, 0x33, 0x14, 0x98,
+	0x43, 0x62, 0xe3, 0x28, 0x75, 0xb5, 0xca, 0x5d, 0x75, 0x8b, 0x5c, 0x7d, 0x83, 0x22, 0xfb, 0xdb,
-	0xcf, 0x93, 0xc3, 0x07, 0xe2, 0x6c, 0xec, 0x6f, 0x4b, 0xbc, 0xb9, 0xf5, 0xfc, 0x1c, 0xaa, 0xaf,
+	0x34, 0xf9, 0x5c, 0xe6, 0x0a, 0x7f, 0x07, 0xf2, 0xce, 0xed, 0x16, 0x63, 0xa8, 0xb9, 0x7b, 0x5d,
-	0x9f, 0xe4, 0x6f, 0xc2, 0x37, 0x60, 0xf9, 0xa6, 0xdf, 0xc2, 0xcf, 0x3c, 0xf7, 0xf3, 0x6f, 0x9e,
+	0xbc, 0x09, 0x7f, 0x02, 0x9b, 0xcf, 0xfd, 0x96, 0x7e, 0xd6, 0xb8, 0x9f, 0x8f, 0x8a, 0xfc, 0x1c,
-	0x9f, 0xdd, 0x24, 0x3f, 0xf6, 0xb0, 0x26, 0x3c, 0x94, 0xb2, 0x71, 0xaa, 0x97, 0xcc, 0x6c, 0x00,
+	0xa7, 0x78, 0xe1, 0x61, 0x47, 0x7a, 0xa8, 0xe5, 0xe3, 0xd4, 0xac, 0xd9, 0xf9, 0x00, 0xbc, 0x04,
-	0x1e, 0x81, 0x22, 0xef, 0xb9, 0xc0, 0x00, 0x8e, 0xf9, 0x27, 0x0f, 0xd3, 0xea, 0x21, 0x3f, 0x26,
+	0x15, 0xde, 0x73, 0x29, 0x03, 0xb8, 0xcc, 0x87, 0x45, 0x32, 0xbd, 0x11, 0x0a, 0x85, 0x02, 0x94,
-	0x40, 0x41, 0x00, 0xc3, 0x10, 0xd5, 0x01, 0x1d, 0xae, 0xa1, 0x01, 0x2a, 0x14, 0x75, 0x89, 0x6b,
+	0x0a, 0x60, 0x1a, 0xa2, 0x26, 0xa0, 0xd3, 0x35, 0xb4, 0x40, 0x83, 0xa2, 0x21, 0xf1, 0x1d, 0x9a,
-	0xd1, 0xec, 0x38, 0x15, 0x27, 0x1c, 0x27, 0x28, 0xd4, 0xd2, 0x13, 0x65, 0x80, 0xa5, 0x84, 0x21,
+	0x1f, 0xa7, 0xca, 0x82, 0xe3, 0x04, 0x25, 0x5b, 0x76, 0xa2, 0x2c, 0x50, 0x4d, 0x35, 0xa4, 0xfd,
-	0xec, 0x2f, 0x70, 0xfb, 0xdb, 0xb9, 0xf6, 0xe3, 0xec, 0xb8, 0x82, 0x15, 0x51, 0xc1, 0x62, 0x3a,
+	0x75, 0x6e, 0xff, 0xb0, 0xd0, 0xbe, 0x40, 0x8b, 0x0a, 0xb6, 0x64, 0x05, 0x1b, 0xd9, 0x28, 0x35,
-	0x4a, 0xf5, 0x45, 0x9a, 0xfe, 0xc9, 0xde, 0x04, 0x46, 0x81, 0x9b, 0x2d, 0x62, 0x71, 0xd2, 0x37,
+	0x37, 0x68, 0xf6, 0x93, 0xdd, 0x09, 0x8c, 0x22, 0x3f, 0x5f, 0xc4, 0xc6, 0xa2, 0x77, 0x82, 0x51,
-	0xc1, 0xa4, 0xd2, 0x15, 0x1c, 0x81, 0x22, 0x57, 0x17, 0xf6, 0x97, 0xee, 0xbe, 0xfd, 0x27, 0x28,
+	0x65, 0x2b, 0xb8, 0x04, 0x15, 0xce, 0x2e, 0xed, 0x57, 0x5f, 0x3f, 0xfd, 0x13, 0x14, 0xf9, 0x33,
-	0x70, 0x47, 0x6e, 0x7f, 0x18, 0xa2, 0x3a, 0xc0, 0xc3, 0xb5, 0xb6, 0x77, 0xfe, 0x5d, 0x2e, 0x9c,
+	0xa7, 0x3f, 0x0d, 0x51, 0x13, 0xe0, 0xe9, 0x1a, 0x9e, 0x80, 0xb2, 0xa4, 0xac, 0x71, 0xca, 0x0f,
-	0x0f, 0x64, 0xe9, 0x62, 0x20, 0x4b, 0xdf, 0x06, 0xb2, 0x74, 0x76, 0x2d, 0x17, 0x2e, 0xae, 0xe5,
+	0x8a, 0x28, 0x05, 0x5d, 0x55, 0xd2, 0x95, 0x25, 0x95, 0x4c, 0x36, 0x4e, 0xef, 0xfe, 0x55, 0x4b,
-	0xc2, 0xd7, 0x6b, 0xb9, 0xf0, 0xea, 0x9e, 0x45, 0xc2, 0x93, 0xc8, 0x50, 0x3a, 0x9e, 0xa3, 0x32,
+	0x77, 0x13, 0x55, 0xb9, 0x9f, 0xa8, 0xca, 0x3f, 0x13, 0x55, 0xb9, 0x7d, 0x52, 0x4b, 0xf7, 0x4f,
-	0xd4, 0x7d, 0x1b, 0x19, 0x94, 0xaf, 0xd4, 0xd3, 0xd4, 0x77, 0x9e, 0x7d, 0x8e, 0xa9, 0x31, 0xcb,
+	0x6a, 0xe9, 0xef, 0x27, 0xb5, 0xf4, 0xc3, 0xa7, 0x0e, 0x89, 0xaf, 0x13, 0x4b, 0x1b, 0x04, 0x9e,
-	0xbf, 0xa6, 0x0f, 0x7e, 0x04, 0x00, 0x00, 0xff, 0xff, 0x40, 0x8f, 0xb7, 0x18, 0x7f, 0x08, 0x00,
+	0xce, 0xe8, 0x3f, 0x73, 0x91, 0x45, 0xf9, 0x4a, 0xbf, 0xc9, 0xfc, 0x5d, 0x60, 0xaf, 0x3a, 0xb5,
-	0x00,
+	0xca, 0xfc, 0x51, 0xfe, 0xfc, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc0, 0xab, 0xe5, 0xd0, 0xc6,
+	0x08, 0x00, 0x00,
 }
 
 func (m *AccumulationTime) Marshal() (dAtA []byte, err error) {
@@ -329,6 +331,20 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.Claims) > 0 {
+		for iNdEx := len(m.Claims) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Claims[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x7a
+		}
+	}
 	if len(m.EarnClaims) > 0 {
 		for iNdEx := len(m.EarnClaims) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -601,6 +617,12 @@ func (m *GenesisState) Size() (n int) {
 			n += 1 + l + sovGenesis(uint64(l))
 		}
 	}
+	if len(m.Claims) > 0 {
+		for _, e := range m.Claims {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
 	return n
 }
 
@@ -1340,6 +1362,40 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 15:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Claims", 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.Claims = append(m.Claims, Claim{})
+			if err := m.Claims[len(m.Claims)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenesis(dAtA[iNdEx:])

x/incentive/types/genesis_test.go

@@ -68,16 +68,17 @@ func TestGenesisState_Validate(t *testing.T) {
 						RewardIndexes:  normalRewardIndexes,
 					}},
 				},
-				USDXMintingClaims: USDXMintingClaims{
+				Claims: Claims{
 					{
-						BaseClaim: BaseClaim{
+						Type:   CLAIM_TYPE_USDX_MINTING,
-							Owner:  sdk.AccAddress(crypto.AddressHash([]byte("KavaTestUser1"))),
+						Owner:  sdk.AccAddress(crypto.AddressHash([]byte("KavaTestUser1"))),
-							Reward: sdk.NewCoin("ukava", sdk.NewInt(100000000)),
+						Reward: cs(c("ukava", 100000000)),
-						},
+						RewardIndexes: []MultiRewardIndex{
-						RewardIndexes: []RewardIndex{
 							{
 								CollateralType: "bnb-a",
-								RewardFactor:   sdk.ZeroDec(),
+								RewardIndexes: RewardIndexes{
+									NewRewardIndex(USDXMintingRewardDenom, sdk.ZeroDec()),
+								},
 							},
 						},
 					},
@@ -101,7 +102,7 @@ func TestGenesisState_Validate(t *testing.T) {
 						RewardIndexes:  normalRewardIndexes,
 					}},
 				},
-				USDXMintingClaims: DefaultUSDXClaims,
+				Claims: DefaultClaims,
 			},
 			errArgs: errArgs{
 				expectPass: false,
@@ -113,16 +114,17 @@ func TestGenesisState_Validate(t *testing.T) {
 			genesis: GenesisState{
 				Params:          DefaultParams(),
 				USDXRewardState: DefaultGenesisRewardState,
-				USDXMintingClaims: USDXMintingClaims{
+				Claims: Claims{
 					{
-						BaseClaim: BaseClaim{
+						Type:   CLAIM_TYPE_USDX_MINTING,
-							Owner:  nil, // invalid address
+						Owner:  nil, // invalid address
-							Reward: sdk.NewCoin("ukava", sdk.NewInt(100000000)),
+						Reward: cs(c("ukava", 100000000)),
-						},
+						RewardIndexes: []MultiRewardIndex{
-						RewardIndexes: []RewardIndex{
 							{
 								CollateralType: "bnb-a",
-								RewardFactor:   sdk.ZeroDec(),
+								RewardIndexes: RewardIndexes{
+									NewRewardIndex(USDXMintingRewardDenom, sdk.ZeroDec()),
+								},
 							},
 						},
 					},

x/incentive/types/keys.go

@@ -1,5 +1,7 @@
 package types
 
+import "encoding/binary"
+
 const (
 	// ModuleName The name that will be used throughout the module
 	ModuleName = "incentive"
@@ -40,3 +42,42 @@ var (
 	EarnRewardIndexesKeyPrefix                    = []byte{0x19} // prefix for key that stores earn reward indexes
 	PreviousEarnRewardAccrualTimeKeyPrefix        = []byte{0x20} // prefix for key that stores the previous time earn rewards accrued
 )
+
+var (
+	ClaimKeyPrefix                     = []byte{0x21}
+	RewardIndexesKeyPrefix             = []byte{0x22}
+	PreviousRewardAccrualTimeKeyPrefix = []byte{0x23}
+)
+
+var sep = []byte("|")
+
+func createKey(bytes ...[]byte) (r []byte) {
+	for _, b := range bytes {
+		r = append(r, b...)
+	}
+	return
+}
+
+func getKeyPrefix(dataTypePrefix []byte, claimType ClaimType) []byte {
+	b := make([]byte, 4)
+	binary.BigEndian.PutUint32(b, uint32(claimType))
+
+	return createKey(dataTypePrefix, sep, b)
+}
+
+// GetClaimKeyPrefix returns the claim store key prefix for the given ClaimType.
+func GetClaimKeyPrefix(claimType ClaimType) []byte {
+	return getKeyPrefix(ClaimKeyPrefix, claimType)
+}
+
+// GetRewardIndexesKeyPrefix returns the reward indexes key prefix for the given
+// ClaimType.
+func GetRewardIndexesKeyPrefix(claimType ClaimType) []byte {
+	return getKeyPrefix(RewardIndexesKeyPrefix, claimType)
+}
+
+// GetPreviousRewardAccrualTimeKeyPrefix returns the previous reward accrual time
+// key prefix for the given ClaimType.
+func GetPreviousRewardAccrualTimeKeyPrefix(claimType ClaimType) []byte {
+	return getKeyPrefix(PreviousRewardAccrualTimeKeyPrefix, claimType)
+}