add genesis for distribution

proto/exocore/feedistribution/v1/genesis.proto

@@ -20,17 +20,55 @@ message GenesisState {
   FeePool fee_pool = 2 [(gogoproto.nullable) = false];
   // validator_accumulated_commissions represents accumulated commission
   // for a validator kept as a running counter, can be withdrawn at any time.
-  repeated ValidatorAccumulatedCommission validator_accumulated_commissions = 3 [(gogoproto.nullable) = false];
-  // validator_current_rewards represents current rewards and current
+  repeated ValidatorAccumulatedCommissions validator_accumulated_commissions = 3 [(gogoproto.nullable) = false];
+  // validator_current_rewards_list represents current rewards and current
   // period for a validator kept as a running counter and incremented
   // each block as long as the validator's tokens remain constant.
-  repeated ValidatorCurrentRewards validator_current_rewards = 4 [(gogoproto.nullable) = false];
+  repeated ValidatorCurrentRewardsList validator_current_rewards_list = 4 [(gogoproto.nullable) = false];
 
-  // validator_outstanding_rewards represents outstanding (un-withdrawn) rewards
+  // validator_outstanding_rewards_list represents outstanding (un-withdrawn) rewards
   // for a validator inexpensive to track, allows simple sanity checks.
-  repeated ValidatorOutstandingRewards validator_outstanding_rewards = 5 [(gogoproto.nullable) = false];
-  // staker_outstanding_rewards represents outstanding (un-withdrawn) rewards
+  repeated ValidatorOutstandingRewardsList validator_outstanding_rewards_list = 5 [(gogoproto.nullable) = false];
+  // staker_outstanding_rewards_list represents outstanding (un-withdrawn) rewards
   // for a staker inexpensive to track, allows simple sanity checks.
-  repeated StakerOutstandingRewards staker_outstanding_rewards = 6 [(gogoproto.nullable) = false];
+  repeated StakerOutstandingRewardsList staker_outstanding_rewards_list = 6 [(gogoproto.nullable) = false];
 
+}
+
+
+message ValidatorAccumulatedCommissions {
+  // val_addr is the address of validator
+  string val_addr = 1;
+
+  // ValidatorAccumulatedCommission represents accumulated commission
+  // for a validator kept as a running counter, can be withdrawn at any time.
+  ValidatorAccumulatedCommission commission = 2;
+}
+
+message ValidatorCurrentRewardsList {
+  // val_addr is the address of validator
+  string val_addr = 1;
+
+  // ValidatorCurrentRewards represents current rewards and current
+  // period for a validator kept as a running counter and incremented
+  // each block as long as the validator's tokens remain constant.
+  ValidatorCurrentRewards current_rewards = 2;
+}
+
+message ValidatorOutstandingRewardsList {
+  // val_addr is the address of validator
+  string val_addr = 1;
+
+  // ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards
+  // for a validator inexpensive to track, allows simple sanity checks.
+  ValidatorOutstandingRewards outstanding_rewards = 2;
+}
+
+message StakerOutstandingRewardsList {
+  // val_addr is the address of validator
+  string val_addr = 1;
+
+  // StakerOutstandingRewards represents outstanding (un-withdrawn) rewards
+  // for a staker inexpensive to track, allows simple sanity checks.
+  StakerOutstandingRewards staker_outstanding_rewards = 2;
 }

x/avs/keeper/genesis.go

@@ -3,25 +3,91 @@ package keeper
 import (
 	errorsmod "cosmossdk.io/errors"
 	"github.com/ExocoreNetwork/exocore/x/avs/types"
-	abci "github.com/cometbft/cometbft/abci/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/ethereum/go-ethereum/common"
 )
 
 // InitGenesis initializes the module's state from a provided genesis state.
 // Since this action typically occurs on chain starts, this function is allowed to panic.
-func (k Keeper) InitGenesis(ctx sdk.Context, state types.GenesisState) []abci.ValidatorUpdate {
+func (k Keeper) InitGenesis(ctx sdk.Context, state types.GenesisState) {
+	// Set all the avs infos
 	for _, avs := range state.AvsInfos {
-
-		if err := k.SetAVSInfo(ctx, &avs); err != nil { //nolint:gosec
-			panic(errorsmod.Wrap(err, "failed to set avs info"))
+		err := k.SetAVSInfo(ctx, &avs) //nolint:gosec
+		if err != nil {
+			panic(errorsmod.Wrap(err, "failed to set all avs info"))
+		}
+	}
+	// Set all the task infos
+	for _, elem := range state.TaskInfos {
+		err := k.SetTaskInfo(ctx, &elem) //nolint:gosec
+		if err != nil {
+			panic(errorsmod.Wrap(err, "failed to set all task info"))
+		}
+	}
+	// Set all the bls infos
+	for _, elem := range state.BlsPubKeys {
+		err := k.SetOperatorPubKey(ctx, &elem) //nolint:gosec
+		if err != nil {
+			panic(errorsmod.Wrap(err, "failed to set all bls info"))
+		}
+	}
+	// Set all the taskNum infos
+	for _, elem := range state.TaskNums {
+		k.SetTaskID(ctx, common.HexToAddress(elem.TaskAddr), elem.TaskId)
+	}
+	// Set all the task result infos
+	for _, elem := range state.TaskResultInfos {
+		err := k.SetTaskResultInfo(ctx, elem.OperatorAddress, &elem) //nolint:gosec
+		if err != nil {
+			panic(errorsmod.Wrap(err, "failed to set all task result info"))
 		}
 	}
+	// Set all the task challenge infos
+	err := k.SetAllTaskChallengedInfo(ctx, state.ChallengeInfos)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to set all challenge info"))
+	}
+	// Set all the chainID infos
+	for _, elem := range state.ChainIdInfos {
+		k.SetAVSAddrToChainID(ctx, common.HexToAddress(elem.AvsAddress), elem.ChainId)
+	}
 
-	return []abci.ValidatorUpdate{}
 }
 
 func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
 	res := types.GenesisState{}
-	var _ error
+	var err error
+	res.AvsInfos = k.AllAvsInfos(ctx)
+
+	res.TaskInfos, err = k.GetAllTaskInfos(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all task infos").Error())
+	}
+
+	res.BlsPubKeys, err = k.GetAllBlsPubKeys(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all bls key info").Error())
+	}
+
+	res.TaskNums, err = k.GetAllTaskNums(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all TaskNums").Error())
+	}
+
+	res.TaskResultInfos, err = k.GetAllTaskResultInfos(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all TaskResultInfos").Error())
+	}
+
+	res.ChallengeInfos, err = k.GetAllChallengeInfos(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all ChallengeInfos").Error())
+	}
+
+	res.ChainIdInfos, err = k.GetAllChainIdInfos(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all ChainIdInfos").Error())
+	}
+
 	return &res
 }

x/avs/keeper/task.go

@@ -125,6 +125,10 @@ func (k Keeper) GetTaskID(ctx sdk.Context, taskAddr common.Address) uint64 {
 	store.Set(taskAddr.Bytes(), sdk.Uint64ToBigEndian(id))
 	return id
 }
+func (k Keeper) SetTaskID(ctx sdk.Context, taskAddr common.Address, id uint64) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefixLatestTaskNum)
+	store.Set(taskAddr.Bytes(), sdk.Uint64ToBigEndian(id))
+}
 
 // SetTaskResultInfo is used to store the operator's sign task information.
 func (k *Keeper) SetTaskResultInfo(
@@ -371,7 +375,18 @@ func (k *Keeper) SetTaskChallengedInfo(
 
 	return nil
 }
-
+func (k *Keeper) SetAllTaskChallengedInfo(ctx sdk.Context, states []types.ChallengeInfo) error {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefixTaskChallengeResult)
+	for i := range states {
+		state := states[i]
+		bz, err := sdk.AccAddressFromBech32(state.ChallengeAddr)
+		if err != nil {
+			return err
+		}
+		store.Set([]byte(state.Key), bz)
+	}
+	return nil
+}
 func (k *Keeper) IsExistTaskChallengedInfo(ctx sdk.Context, operatorAddress, taskContractAddress string, taskID uint64) bool {
 	infoKey := assetstype.GetJoinedStoreKey(operatorAddress, taskContractAddress,
 		strconv.FormatUint(taskID, 10))

x/feedistribution/keeper/genesis.go

@@ -1,6 +1,7 @@
 package keeper
 
 import (
+	errorsmod "cosmossdk.io/errors"
 	"github.com/ExocoreNetwork/exocore/x/feedistribution/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -15,11 +16,59 @@ func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) {
 		// is not running. it means that the genesis file is malformed.
 		panic("not found the epoch info")
 	}
+
+	// Set fee pool
+	k.SetFeePool(ctx, &genState.FeePool)
+
+	// Set all the validatorAccumulatedCommission
+	for _, elem := range genState.ValidatorAccumulatedCommissions {
+		k.SetValidatorAccumulatedCommission(ctx, sdk.ValAddress(elem.ValAddr), *elem.Commission)
+	}
+
+	// Set all the validatorCurrentRewards
+	for _, elem := range genState.ValidatorCurrentRewardsList {
+		k.SetValidatorCurrentRewards(ctx, sdk.ValAddress(elem.ValAddr), *elem.CurrentRewards)
+	}
+
+	// Set all the validatorOutstandingRewards
+	for _, elem := range genState.ValidatorOutstandingRewardsList {
+		k.SetValidatorOutstandingRewards(ctx, sdk.ValAddress(elem.ValAddr), *elem.OutstandingRewards)
+	}
+
+	// Set all the stakerRewards
+	for _, elem := range genState.StakerOutstandingRewardsList {
+		k.SetStakerRewards(ctx, elem.ValAddr, *elem.StakerOutstandingRewards)
+	}
+
 }
 
 // ExportGenesis returns the module's exported genesis
 func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
 	genesis := types.DefaultGenesis()
 	genesis.Params = k.GetParams(ctx)
+
+	feelPool := k.GetFeePool(ctx)
+
+	genesis.FeePool = *feelPool
+
+	genesis.ValidatorAccumulatedCommissions, err := k.GetAllValidatorAccumulatedCommissions(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all ValidatorAccumulatedCommissions").Error())
+	}
+
+	genesis.ValidatorCurrentRewardsList, err = k.GetAllValidatorCurrentRewardsList(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all ValidatorCurrentRewardsList").Error())
+	}
+
+	genesis.ValidatorOutstandingRewardsList, err = k.GetAllValidatorOutstandingRewardsList(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all ValidatorOutstandingRewardsList").Error())
+	}
+
+	genesis.StakerOutstandingRewardsList, err = k.GetAllStakerOutstandingRewardsList(ctx)
+	if err != nil {
+		panic(errorsmod.Wrap(err, "failed to get all StakerOutstandingRewardsList").Error())
+	}
 	return genesis
 }