feat(participation): decay support

proto/claim/params.proto

@@ -2,10 +2,20 @@ syntax = "proto3";
 package tendermint.spn.claim;
 
 import "gogoproto/gogo.proto";
+import "google/protobuf/timestamp.proto";
 
 option go_package = "github.com/tendermint/spn/x/claim/types";
 
 // Params defines the parameters for the module.
 message Params {
+  DecayInformation decayInformation = 1 [(gogoproto.nullable) = false];
   option (gogoproto.goproto_stringer) = false;
 }
+
+// DecayInformation defines the information about decay for the airdrop
+// when claimable airdrop amount starts to decrease and when it ends
+message DecayInformation {
+  bool enabled = 1;
+  google.protobuf.Timestamp decayStart = 2 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  google.protobuf.Timestamp decayEnd = 3 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+}

testutil/keeper/initializer.go

@@ -443,7 +443,7 @@ func (i initializer) Claim(
 	i.StateStore.MountStoreWithDB(memStoreKey, sdk.StoreTypeMemory, nil)
 
 	paramKeeper.Subspace(claimtypes.ModuleName)
-	subspace, _ := paramKeeper.GetSubspace(participationtypes.ModuleName)
+	subspace, _ := paramKeeper.GetSubspace(claimtypes.ModuleName)
 
 	return claimkeeper.NewKeeper(
 		i.Codec,

x/claim/keeper/mission.go

@@ -93,8 +93,17 @@ func (k Keeper) CompleteMission(ctx sdk.Context, missionID uint64, address strin
 	claimableAmount := claimRecord.ClaimableFromMission(mission)
 	claimable := sdk.NewCoins(sdk.NewCoin(airdropSupply.Denom, claimableAmount))
 
+	// calculate claimable after decay factor
+	decayInfo := k.DecayInformation(ctx)
+	claimable = decayInfo.ApplyDecayFactor(claimable, ctx.BlockTime())
+
+	// check final claimable non-zero
+	if claimable.Empty() {
+		return types.ErrNoClaimable
+	}
+
 	// decrease airdrop supply
-	airdropSupply.Amount = airdropSupply.Amount.Sub(claimableAmount)
+	airdropSupply.Amount = airdropSupply.Amount.Sub(claimable.AmountOf(airdropSupply.Denom))
 	if airdropSupply.Amount.IsNegative() {
 		return spnerrors.Critical("airdrop supply is lower than total claimable")
 	}

x/claim/keeper/mission_test.go

@@ -2,6 +2,7 @@ package keeper_test
 
 import (
 	"testing"
+	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
@@ -70,6 +71,8 @@ func TestKeeper_CompleteMission(t *testing.T) {
 		airdropSupply   sdk.Coin
 		mission         types.Mission
 		claimRecord     types.ClaimRecord
+		params          types.Params
+		blockTime       time.Time
 	}
 
 	// prepare addresses
@@ -92,6 +95,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 				noAirdropSupply: true,
 				claimRecord:     sample.ClaimRecord(r),
 				mission:         sample.Mission(r),
+				params:          types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   sample.Address(r),
@@ -107,6 +111,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Claimable:         sdk.OneInt(),
 					CompletedMissions: []uint64{1},
 				},
+				params: types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   addr[0],
@@ -121,6 +126,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					MissionID: 1,
 					Weight:    sdk.OneDec(),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   sample.Address(r),
@@ -139,6 +145,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Claimable:         sdk.OneInt(),
 					CompletedMissions: []uint64{1},
 				},
+				params: types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   addr[1],
@@ -156,6 +163,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[2],
 					Claimable: sdk.NewIntFromUint64(10000),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   addr[2],
@@ -173,6 +181,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   "invalid",
 					Claimable: sdk.OneInt(),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID: 1,
 			address:   "invalid",
@@ -190,13 +199,14 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[3],
 					Claimable: sdk.NewIntFromUint64(1000),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID:       1,
 			address:         addr[3],
 			expectedBalance: tc.Coin(t, "1000foo"),
 		},
 		{
-			name: "should allow distributing no fund for mission with 0 weight",
+			name: "should prevent distributing fund for mission with 0 weight",
 			inputState: inputState{
 				airdropSupply: tc.Coin(t, "1000foo"),
 				mission: types.Mission{
@@ -207,10 +217,11 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[4],
 					Claimable: sdk.NewIntFromUint64(1000),
 				},
+				params: types.DefaultParams(),
 			},
-			missionID:       1,
-			address:         addr[4],
-			expectedBalance: tc.Coin(t, "0foo"),
+			missionID: 1,
+			address:   addr[4],
+			err:       types.ErrNoClaimable,
 		},
 		{
 			name: "should allow distributing half for mission with 0.5 weight",
@@ -224,6 +235,7 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[5],
 					Claimable: sdk.NewIntFromUint64(500),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID:       1,
 			address:         addr[5],
@@ -241,13 +253,14 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[6],
 					Claimable: sdk.NewIntFromUint64(201),
 				},
+				params: types.DefaultParams(),
 			},
 			missionID:       1,
 			address:         addr[6],
 			expectedBalance: tc.Coin(t, "100foo"),
 		},
 		{
-			name: "should allow distributing no fund for empty claim record",
+			name: "should prevent distributing fund for empty claim record",
 			inputState: inputState{
 				airdropSupply: tc.Coin(t, "1000foo"),
 				mission: types.Mission{
@@ -258,10 +271,11 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Address:   addr[7],
 					Claimable: sdk.ZeroInt(),
 				},
+				params: types.DefaultParams(),
 			},
-			missionID:       1,
-			address:         addr[7],
-			expectedBalance: tc.Coin(t, "0foo"),
+			missionID: 1,
+			address:   addr[7],
+			err:       types.ErrNoClaimable,
 		},
 		{
 			name: "should allow distributing airdrop with other already completed missions",
@@ -276,15 +290,84 @@ func TestKeeper_CompleteMission(t *testing.T) {
 					Claimable:         sdk.NewIntFromUint64(10000),
 					CompletedMissions: []uint64{0, 1, 2, 4, 5, 6},
 				},
+				params: types.DefaultParams(),
 			},
 			missionID:       3,
 			address:         addr[8],
 			expectedBalance: tc.Coin(t, "3000bar"),
 		},
+		{
+			name: "should allow applying decay factor if enabled",
+			inputState: inputState{
+				airdropSupply: tc.Coin(t, "1000foo"),
+				mission: types.Mission{
+					MissionID: 1,
+					Weight:    tc.Dec(t, "0.5"),
+				},
+				claimRecord: types.ClaimRecord{
+					Address:   addr[9],
+					Claimable: sdk.NewIntFromUint64(1000),
+				},
+				params: types.NewParams(types.NewEnabledDecay(
+					time.Unix(1000, 0),
+					time.Unix(2000, 0),
+				)),
+				blockTime: time.Unix(1500, 0),
+			},
+			missionID:       1,
+			address:         addr[9],
+			expectedBalance: tc.Coin(t, "250foo"),
+		},
+		{
+			name: "should allow distributing all funds if decay factor if enabled and decay not started",
+			inputState: inputState{
+				airdropSupply: tc.Coin(t, "1000foo"),
+				mission: types.Mission{
+					MissionID: 1,
+					Weight:    tc.Dec(t, "0.5"),
+				},
+				claimRecord: types.ClaimRecord{
+					Address:   addr[10],
+					Claimable: sdk.NewIntFromUint64(1000),
+				},
+				params: types.NewParams(types.NewEnabledDecay(
+					time.Unix(1000, 0),
+					time.Unix(2000, 0),
+				)),
+				blockTime: time.Unix(999, 0),
+			},
+			missionID:       1,
+			address:         addr[10],
+			expectedBalance: tc.Coin(t, "500foo"),
+		},
+		{
+			name: "should prevent distributing funds if decay ended",
+			inputState: inputState{
+				airdropSupply: tc.Coin(t, "1000foo"),
+				mission: types.Mission{
+					MissionID: 1,
+					Weight:    tc.Dec(t, "0.5"),
+				},
+				claimRecord: types.ClaimRecord{
+					Address:   addr[11],
+					Claimable: sdk.NewIntFromUint64(1000),
+				},
+				params: types.NewParams(types.NewEnabledDecay(
+					time.Unix(1000, 0),
+					time.Unix(2000, 0),
+				)),
+				blockTime: time.Unix(2001, 0),
+			},
+			missionID: 1,
+			address:   addr[11],
+			err:       types.ErrNoClaimable,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// initialize input state
+			require.NoError(t, tt.inputState.params.Validate())
+			tk.ClaimKeeper.SetParams(ctx, tt.inputState.params)
 			if !tt.inputState.noAirdropSupply {
 				err := tk.ClaimKeeper.InitializeAirdropSupply(ctx, tt.inputState.airdropSupply)
 				require.NoError(t, err)
@@ -295,6 +378,9 @@ func TestKeeper_CompleteMission(t *testing.T) {
 			if !tt.inputState.noClaimRecord {
 				tk.ClaimKeeper.SetClaimRecord(ctx, tt.inputState.claimRecord)
 			}
+			if !tt.inputState.blockTime.IsZero() {
+				ctx = ctx.WithBlockTime(tt.inputState.blockTime)
+			}
 
 			err := tk.ClaimKeeper.CompleteMission(ctx, tt.missionID, tt.address)
 			if tt.err != nil {

x/claim/keeper/params.go

@@ -7,11 +7,18 @@ import (
 )
 
 // GetParams get all parameters as types.Params
-func (k Keeper) GetParams(ctx sdk.Context) types.Params {
-	return types.NewParams()
+func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
+	k.paramstore.GetParamSet(ctx, &params)
+	return params
 }
 
 // SetParams set the params
 func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
 	k.paramstore.SetParamSet(ctx, &params)
 }
+
+// DecayInformation returns the param that defines decay information
+func (k Keeper) DecayInformation(ctx sdk.Context) (totalSupplyRange types.DecayInformation) {
+	k.paramstore.Get(ctx, types.KeyDecayInformation, &totalSupplyRange)
+	return
+}

x/claim/keeper/params_test.go

@@ -2,6 +2,7 @@ package keeper_test
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -12,9 +13,10 @@ import (
 func TestGetParams(t *testing.T) {
 	ctx, tk, _ := testkeeper.NewTestSetup(t)
 
-	params := types.DefaultParams()
-
+	params := types.NewParams(types.NewEnabledDecay(
+		time.Unix(1000, 0),
+		time.Unix(10000, 0),
+	))
 	tk.ClaimKeeper.SetParams(ctx, params)
-
 	require.EqualValues(t, params, tk.ClaimKeeper.GetParams(ctx))
 }

x/claim/types/decay.go

@@ -0,0 +1,77 @@
+package types
+
+import (
+	"fmt"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// NewDisabledDecay returns decay information with disabled decay
+func NewDisabledDecay() DecayInformation {
+	// convert all time to UTC
+	return DecayInformation{
+		Enabled:    false,
+		DecayStart: time.UnixMilli(0).UTC(),
+		DecayEnd:   time.UnixMilli(0).UTC(),
+	}
+}
+
+// NewEnabledDecay returns decay information with a decay start and end
+func NewEnabledDecay(start, end time.Time) DecayInformation {
+	// convert all time to UTC
+	return DecayInformation{
+		Enabled:    true,
+		DecayStart: start.UTC(),
+		DecayEnd:   end.UTC(),
+	}
+}
+
+// Validate validates the decay information
+func (m DecayInformation) Validate() error {
+	if m.Enabled && m.DecayStart.After(m.DecayEnd) {
+		return fmt.Errorf("decay starts after decay end %s > %s", m.DecayStart.String(), m.DecayEnd.String())
+	}
+
+	return nil
+}
+
+// ApplyDecayFactor reduces the coins depending on the decay factor from decay information
+// coins decrease from decay start to zero at decay end
+func (m DecayInformation) ApplyDecayFactor(coins sdk.Coins, currentTime time.Time) sdk.Coins {
+	// no decay factor applied
+	if coins.Empty() || !m.Enabled || currentTime.Before(m.DecayStart) {
+		return coins
+	}
+
+	// coins reduced to 0 if decay ended
+	if currentTime.Equal(m.DecayEnd) || currentTime.After(m.DecayEnd) {
+		return sdk.NewCoins()
+	}
+
+	// calculate decay factor
+	timeToDec := func(t time.Time) sdk.Dec {
+		return sdk.NewDecFromInt(sdk.NewInt(t.Unix()))
+	}
+
+	current, start, end := timeToDec(currentTime), timeToDec(m.DecayStart), timeToDec(m.DecayEnd)
+
+	// (end-current)/(end-start)
+	decayFactor := (end.Sub(current)).Quo(end.Sub(start))
+
+	// apply decay factor to each denom
+	newCoins := sdk.NewCoins()
+	for _, coin := range coins {
+		amountDec := sdk.NewDecFromInt(coin.Amount)
+		newAmount := amountDec.Mul(decayFactor).TruncateInt()
+
+		if !newAmount.IsZero() {
+			newCoins = append(newCoins, sdk.NewCoin(
+				coin.Denom,
+				newAmount,
+			))
+		}
+	}
+
+	return newCoins.Sort()
+}