use if exist in emissions

x/emissions/abci.go

@@ -18,9 +18,9 @@ func BeginBlocker(ctx sdk.Context, keeper keeper.Keeper) {
 		ctx.Logger().Info(fmt.Sprintf("Block rewards %s are greater than emission pool balance %s", blockRewards.String(), emissionPoolBalance.String()))
 		return
 	}
-	validatorRewards := sdk.MustNewDecFromStr(keeper.GetParams(ctx).ValidatorEmissionPercentage).Mul(blockRewards).TruncateInt()
-	observerRewards := sdk.MustNewDecFromStr(keeper.GetParams(ctx).ObserverEmissionPercentage).Mul(blockRewards).TruncateInt()
-	tssSignerRewards := sdk.MustNewDecFromStr(keeper.GetParams(ctx).TssSignerEmissionPercentage).Mul(blockRewards).TruncateInt()
+
+	// Get the distribution of rewards
+	validatorRewards, observerRewards, tssSignerRewards := keeper.GetDistributions(ctx)
 
 	// Use a tmpCtx, which is a cache-wrapped context to avoid writing to the store
 	// We commit only if all three distributions are successful, if not the funds stay in the emission pool
@@ -62,7 +62,6 @@ func DistributeValidatorRewards(ctx sdk.Context, amount sdkmath.Int, bankKeeper
 // The total rewards are distributed equally among all Successful votes
 // NotVoted or Unsuccessful votes are slashed
 // rewards given or slashed amounts are in azeta
-
 func DistributeObserverRewards(ctx sdk.Context, amount sdkmath.Int, keeper keeper.Keeper) error {
 
 	rewardsDistributer := map[string]int64{}
@@ -113,7 +112,7 @@ func DistributeObserverRewards(ctx sdk.Context, amount sdkmath.Int, keeper keepe
 			continue
 		}
 		if observerRewardUnits < 0 {
-			slashAmount := keeper.GetParams(ctx).ObserverSlashAmount
+			slashAmount := keeper.GetParamSetIfExists(ctx).ObserverSlashAmount
 			keeper.SlashObserverEmission(ctx, observerAddress.String(), slashAmount)
 			finalDistributionList = append(finalDistributionList, &types.ObserverEmission{
 				EmissionType:    types.EmissionType_Slash,

x/emissions/abci_test.go

@@ -102,9 +102,9 @@ func TestBeginBlocker(t *testing.T) {
 		emissionPool := sk.AuthKeeper.GetModuleAccount(ctx, emissionstypes.ModuleName).GetAddress()
 
 		blockRewards := emissionstypes.BlockReward
-		observerRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParams(ctx).ObserverEmissionPercentage)).TruncateInt()
-		validatorRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParams(ctx).ValidatorEmissionPercentage)).TruncateInt()
-		tssSignerRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParams(ctx).TssSignerEmissionPercentage)).TruncateInt()
+		observerRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).ObserverEmissionPercentage)).TruncateInt()
+		validatorRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).ValidatorEmissionPercentage)).TruncateInt()
+		tssSignerRewardsForABlock := blockRewards.Mul(sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).TssSignerEmissionPercentage)).TruncateInt()
 		distributedRewards := observerRewardsForABlock.Add(validatorRewardsForABlock).Add(tssSignerRewardsForABlock)
 
 		require.True(t, blockRewards.TruncateInt().GT(distributedRewards))

x/emissions/genesis.go

@@ -19,7 +19,7 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState)
 // ExportGenesis returns the emissions module's exported genesis.
 func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
 	var genesis types.GenesisState
-	genesis.Params = k.GetParams(ctx)
+	genesis.Params = k.GetParamSetIfExists(ctx)
 	genesis.WithdrawableEmissions = k.GetAllWithdrawableEmission(ctx)
 
 	return &genesis

x/emissions/keeper/block_rewards_components.go

@@ -17,9 +17,9 @@ func (k Keeper) GetBlockRewardComponents(ctx sdk.Context) (sdk.Dec, sdk.Dec, sdk
 	return reservesFactor, bondFactor, durationFactor
 }
 func (k Keeper) GetBondFactor(ctx sdk.Context, stakingKeeper types.StakingKeeper) sdk.Dec {
-	targetBondRatio := sdk.MustNewDecFromStr(k.GetParams(ctx).TargetBondRatio)
-	maxBondFactor := sdk.MustNewDecFromStr(k.GetParams(ctx).MaxBondFactor)
-	minBondFactor := sdk.MustNewDecFromStr(k.GetParams(ctx).MinBondFactor)
+	targetBondRatio := sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).TargetBondRatio)
+	maxBondFactor := sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).MaxBondFactor)
+	minBondFactor := sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).MinBondFactor)
 
 	currentBondedRatio := stakingKeeper.BondedRatio(ctx)
 	// Bond factor ranges between minBondFactor (0.75) to maxBondFactor (1.25)
@@ -37,10 +37,10 @@ func (k Keeper) GetBondFactor(ctx sdk.Context, stakingKeeper types.StakingKeeper
 }
 
 func (k Keeper) GetDurationFactor(ctx sdk.Context) sdk.Dec {
-	avgBlockTime := sdk.MustNewDecFromStr(k.GetParams(ctx).AvgBlockTime)
+	avgBlockTime := sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).AvgBlockTime)
 	NumberOfBlocksInAMonth := sdk.NewDec(types.SecsInMonth).Quo(avgBlockTime)
 	monthFactor := sdk.NewDec(ctx.BlockHeight()).Quo(NumberOfBlocksInAMonth)
-	logValueDec := sdk.MustNewDecFromStr(k.GetParams(ctx).DurationFactorConstant)
+	logValueDec := sdk.MustNewDecFromStr(k.GetParamSetIfExists(ctx).DurationFactorConstant)
 	// month * log(1 + 0.02 / 12)
 	fractionNumerator := monthFactor.Mul(logValueDec)
 	// (month * log(1 + 0.02 / 12) ) + 1

x/emissions/keeper/distributions.go

@@ -0,0 +1,35 @@
+package keeper
+
+import (
+	sdkmath "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/zeta-chain/zetacore/x/emissions/types"
+)
+
+// GetDistributions returns the current distribution of rewards
+// for validators, observers and TSS signers
+// If the percentage is not set, it returns 0
+func (k Keeper) GetDistributions(ctx sdk.Context) (sdkmath.Int, sdkmath.Int, sdkmath.Int) {
+	// Fetch the validator rewards, use 0 if the percentage is not set
+	validatorRewards := sdk.NewInt(0)
+	validatorRewardsDec, err := sdk.NewDecFromStr(k.GetParamSetIfExists(ctx).ValidatorEmissionPercentage)
+	if err == nil {
+		validatorRewards = validatorRewardsDec.Mul(types.BlockReward).TruncateInt()
+	}
+
+	// Fetch the observer rewards, use 0 if the percentage is not set
+	observerRewards := sdk.NewInt(0)
+	observerRewardsDec, err := sdk.NewDecFromStr(k.GetParamSetIfExists(ctx).ObserverEmissionPercentage)
+	if err == nil {
+		observerRewards = observerRewardsDec.Mul(types.BlockReward).TruncateInt()
+	}
+
+	// Fetch the TSS signer rewards, use 0 if the percentage is not set
+	tssSignerRewards := sdk.NewInt(0)
+	tssSignerRewardsDec, err := sdk.NewDecFromStr(k.GetParamSetIfExists(ctx).TssSignerEmissionPercentage)
+	if err == nil {
+		tssSignerRewards = tssSignerRewardsDec.Mul(types.BlockReward).TruncateInt()
+	}
+
+	return validatorRewards, observerRewards, tssSignerRewards
+}

x/emissions/keeper/grpc_query_params.go

@@ -15,5 +15,5 @@ func (k Keeper) Params(c context.Context, req *types.QueryParamsRequest) (*types
 	}
 	ctx := sdk.UnwrapSDKContext(c)
 
-	return &types.QueryParamsResponse{Params: k.GetParams(ctx)}, nil
+	return &types.QueryParamsResponse{Params: k.GetParamSetIfExists(ctx)}, nil
 }

x/emissions/keeper/params.go

@@ -5,9 +5,10 @@ import (
 	"github.com/zeta-chain/zetacore/x/emissions/types"
 )
 
-// GetParams get all parameters as types.Params
-func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
-	k.paramstore.GetParamSet(ctx, &params)
+// GetParamSetIfExists get all parameters as types.Params if they exist
+// non existent parameters will return zero values
+func (k Keeper) GetParamSetIfExists(ctx sdk.Context) (params types.Params) {
+	k.paramstore.GetParamSetIfExists(ctx, &params)
 	return
 }
 

x/emissions/keeper/params_test.go

@@ -234,9 +234,9 @@ func TestKeeper_GetParams(t *testing.T) {
 			}, tt.isPanic)
 
 			if tt.isPanic != "" {
-				require.Equal(t, emissionstypes.DefaultParams(), k.GetParams(ctx))
+				require.Equal(t, emissionstypes.DefaultParams(), k.GetParamSetIfExists(ctx))
 			} else {
-				require.Equal(t, tt.params, k.GetParams(ctx))
+				require.Equal(t, tt.params, k.GetParamSetIfExists(ctx))
 			}
 		})
 	}