use constructor function for struct construction

Author: colmazia

x/feeds/client/cli/tx.go

@@ -80,19 +80,16 @@ $ %s tx feeds signal BTC,1000000 --from mykey
 					return err
 				}
 				signals = append(
-					signals, types.Signal{
-						ID:    idAndPower[0],
-						Power: power,
-					},
+					signals, types.NewSignal(
+						idAndPower[0],
+						power,
+					),
 				)
 			}
 
-			msg := types.MsgSubmitSignals{
-				Delegator: delegator.String(),
-				Signals:   signals,
-			}
+			msg := types.NewMsgSubmitSignals(delegator.String(), signals)
 
-			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
 		},
 	}
 	flags.AddTxFlagsToCmd(cmd)
@@ -174,17 +171,11 @@ $ %s tx feeds update-reference-source-config <YOUR_IPFS_HASH> 1.0.0 --from mykey
 			}
 
 			admin := clientCtx.GetFromAddress()
-			referenceSourceConfig := types.ReferenceSourceConfig{
-				IPFSHash: args[0],
-				Version:  args[1],
-			}
+			referenceSourceConfig := types.NewReferenceSourceConfig(args[0], args[1])
 
-			msg := types.MsgUpdateReferenceSourceConfig{
-				Admin:                 admin.String(),
-				ReferenceSourceConfig: referenceSourceConfig,
-			}
+			msg := types.NewMsgUpdateReferenceSourceConfig(admin.String(), referenceSourceConfig)
 
-			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
 		},
 	}
 	flags.AddTxFlagsToCmd(cmd)

x/feeds/keeper/genesis.go

@@ -27,9 +27,5 @@ func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) {
 
 // ExportGenesis returns the module's exported genesis
 func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
-	return &types.GenesisState{
-		Params:                k.GetParams(ctx),
-		DelegatorSignals:      k.GetAllDelegatorSignals(ctx),
-		ReferenceSourceConfig: k.GetReferenceSourceConfig(ctx),
-	}
+	return types.NewGenesisState(k.GetParams(ctx), k.GetAllDelegatorSignals(ctx), k.GetReferenceSourceConfig(ctx))
 }

x/feeds/keeper/grpc_query.go

@@ -236,20 +236,16 @@ func (q queryServer) CurrentFeeds(
 		)
 		feedWithDeviations = append(
 			feedWithDeviations,
-			types.FeedWithDeviation{
-				SignalID:            feed.SignalID,
-				Power:               feed.Power,
-				Interval:            feed.Interval,
-				DeviationBasisPoint: deviation,
-			})
+			types.NewFeedWithDeviation(feed.SignalID, feed.Power, feed.Interval, deviation),
+		)
 	}
 
 	return &types.QueryCurrentFeedsResponse{
-		CurrentFeeds: types.CurrentFeedWithDeviations{
-			Feeds:               feedWithDeviations,
-			LastUpdateTimestamp: currentFeeds.LastUpdateTimestamp,
-			LastUpdateBlock:     currentFeeds.LastUpdateBlock,
-		},
+		CurrentFeeds: types.NewCurrentFeedWithDeviations(
+			feedWithDeviations,
+			currentFeeds.LastUpdateTimestamp,
+			currentFeeds.LastUpdateBlock,
+		),
 	}, nil
 }
 

x/feeds/keeper/keeper_feed.go

@@ -20,11 +20,7 @@ func (k Keeper) GetCurrentFeeds(ctx sdk.Context) (sp types.CurrentFeeds) {
 
 // SetCurrentFeeds sets new supported feeds to the store.
 func (k Keeper) SetCurrentFeeds(ctx sdk.Context, feeds []types.Feed) {
-	cf := types.CurrentFeeds{
-		Feeds:               feeds,
-		LastUpdateTimestamp: ctx.BlockTime().Unix(),
-		LastUpdateBlock:     ctx.BlockHeight(),
-	}
+	cf := types.NewCurrentFeeds(feeds, ctx.BlockTime().Unix(), ctx.BlockHeight())
 
 	ctx.KVStore(k.storeKey).Set(types.CurrentFeedsStoreKey, k.cdc.MustMarshal(&cf))
 	emitEventUpdateCurrentFeeds(ctx, cf)
@@ -43,12 +39,14 @@ func (k Keeper) CalculateNewCurrentFeeds(ctx sdk.Context) []types.Feed {
 			params.MaxInterval,
 		)
 		if interval > 0 {
-			feed := types.Feed{
-				SignalID: signalTotalPower.ID,
-				Interval: interval,
-				Power:    signalTotalPower.Power,
-			}
-			feeds = append(feeds, feed)
+			feeds = append(
+				feeds,
+				types.NewFeed(
+					signalTotalPower.ID,
+					signalTotalPower.Power,
+					interval,
+				),
+			)
 		}
 	}
 

x/feeds/keeper/keeper_price.go

@@ -85,12 +85,7 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 				return false
 			}
 			// collect validator information
-			validatorInfo := types.ValidatorInfo{
-				Index:   idx,
-				Address: val.GetOperator(),
-				Power:   val.GetTokens().Uint64(),
-				Status:  status,
-			}
+			validatorInfo := types.NewValidatorInfo(idx, val.GetOperator(), val.GetTokens().Uint64(), status)
 			validatorsByPower = append(validatorsByPower, validatorInfo)
 			return false
 		})
@@ -138,13 +133,13 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 			havePrice := checkHavePrice(feed, valPrice, ctx.BlockTime())
 			if havePrice {
 				priceFeedInfos = append(
-					priceFeedInfos, types.PriceFeedInfo{
-						PriceStatus: valPrice.PriceStatus,
-						Price:       valPrice.Price,
-						Power:       valInfo.Power,
-						Timestamp:   valPrice.Timestamp,
-						Index:       valInfo.Index,
-					},
+					priceFeedInfos, types.NewPriceFeedInfo(
+						valPrice.PriceStatus,
+						valInfo.Power,
+						valPrice.Price,
+						valPrice.Timestamp,
+						valInfo.Index,
+					),
 				)
 			}
 		}
@@ -192,22 +187,22 @@ func (k Keeper) CalculatePrice(
 
 	// If more than half of the total have unsupported price status, it returns an unsupported price status.
 	if unsupportedPower > totalPower/2 {
-		return types.Price{
-			PriceStatus: types.PriceStatusUnsupported,
-			SignalID:    feed.SignalID,
-			Price:       0,
-			Timestamp:   ctx.BlockTime().Unix(),
-		}, nil
+		return types.NewPrice(
+			types.PriceStatusUnsupported,
+			feed.SignalID,
+			0,
+			ctx.BlockTime().Unix(),
+		), nil
 	}
 
 	// If less than half of total have available price status, it returns an unavailable price status.
 	if availablePower < totalPower/2 {
-		return types.Price{
-			PriceStatus: types.PriceStatusUnavailable,
-			SignalID:    feed.SignalID,
-			Price:       0,
-			Timestamp:   ctx.BlockTime().Unix(),
-		}, nil
+		return types.NewPrice(
+			types.PriceStatusUnavailable,
+			feed.SignalID,
+			0,
+			ctx.BlockTime().Unix(),
+		), nil
 	}
 
 	price, err := types.CalculateMedianPriceFeedInfo(
@@ -217,12 +212,12 @@ func (k Keeper) CalculatePrice(
 		return types.Price{}, err
 	}
 
-	return types.Price{
-		PriceStatus: types.PriceStatusAvailable,
-		SignalID:    feed.SignalID,
-		Price:       price,
-		Timestamp:   ctx.BlockTime().Unix(),
-	}, nil
+	return types.NewPrice(
+		types.PriceStatusAvailable,
+		feed.SignalID,
+		price,
+		ctx.BlockTime().Unix(),
+	), nil
 }
 
 // checkMissReport checks if a validator has missed a report based on the given parameters.
@@ -296,10 +291,10 @@ func (k Keeper) SetValidatorPriceList(
 	valAddress sdk.ValAddress,
 	valPrices []types.ValidatorPrice,
 ) error {
-	valPricesList := types.ValidatorPriceList{
-		Validator:       valAddress.String(),
-		ValidatorPrices: valPrices,
-	}
+	valPricesList := types.NewValidatorPriceList(
+		valAddress,
+		valPrices,
+	)
 
 	ctx.KVStore(k.storeKey).Set(types.ValidatorPriceListStoreKey(valAddress), k.cdc.MustMarshal(&valPricesList))
 

x/feeds/keeper/keeper_signal.go

@@ -160,10 +160,10 @@ func (k Keeper) CalculateNewSignalTotalPowers(ctx sdk.Context) []types.Signal {
 
 	signalTotalPowers := []types.Signal{}
 	for _, signalID := range keys {
-		signalTotalPowers = append(signalTotalPowers, types.Signal{
-			ID:    signalID,
-			Power: signalIDToPower[signalID],
-		})
+		signalTotalPowers = append(signalTotalPowers, types.NewSignal(
+			signalID,
+			signalIDToPower[signalID],
+		))
 	}
 
 	return signalTotalPowers
@@ -200,7 +200,7 @@ func (k Keeper) RegisterNewSignals(
 		signalIDToPowerDiff[prevSignal.ID] -= prevSignal.Power
 	}
 
-	k.SetDelegatorSignals(ctx, types.DelegatorSignals{Delegator: delegator.String(), Signals: signals})
+	k.SetDelegatorSignals(ctx, types.NewDelegatorSignals(delegator.String(), signals))
 
 	for _, signal := range signals {
 		signalIDToPowerDiff[signal.ID] += signal.Power

x/feeds/keeper/msg_server.go

@@ -69,10 +69,10 @@ func (ms msgServer) SubmitSignals(
 		signalTotalPower, err := ms.GetSignalTotalPower(ctx, signalID)
 		if err != nil {
 			// initialize a new signal with zero power if the signal ID does not exist
-			signalTotalPower = types.Signal{
-				ID:    signalID,
-				Power: 0,
-			}
+			signalTotalPower = types.NewSignal(
+				signalID,
+				0,
+			)
 		}
 
 		// update the total power of the signal by adding the power difference

x/feeds/types/delegator_signals.go

@@ -5,6 +5,14 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// NewDelegatorSignals creates a new DelegatorSignals instance.
+func NewDelegatorSignals(delegator string, signals []Signal) DelegatorSignals {
+	return DelegatorSignals{
+		Delegator: delegator,
+		Signals:   signals,
+	}
+}
+
 // Validate validates the delegator signals
 func (ds *DelegatorSignals) Validate(maxSignalIDCharacters uint64) error {
 	if _, err := sdk.AccAddressFromBech32(ds.Delegator); err != nil {

x/feeds/types/feed.go

@@ -1,5 +1,59 @@
 package types
 
+// NewFeed creates a new feed instance
+func NewFeed(
+	signalID string,
+	power int64,
+	interval int64,
+) Feed {
+	return Feed{
+		SignalID: signalID,
+		Power:    power,
+		Interval: interval,
+	}
+}
+
+// NewFeedWithDeviation creates a new feed instance with deviation
+func NewFeedWithDeviation(
+	signalID string,
+	power int64,
+	interval int64,
+	deviation int64,
+) FeedWithDeviation {
+	return FeedWithDeviation{
+		SignalID:            signalID,
+		Power:               power,
+		Interval:            interval,
+		DeviationBasisPoint: deviation,
+	}
+}
+
+// NewCurrentFeeds creates a new current feeds instance
+func NewCurrentFeeds(
+	feeds []Feed,
+	lastUpdateTimestamp int64,
+	lastUpdateBlock int64,
+) CurrentFeeds {
+	return CurrentFeeds{
+		Feeds:               feeds,
+		LastUpdateTimestamp: lastUpdateTimestamp,
+		LastUpdateBlock:     lastUpdateBlock,
+	}
+}
+
+// NewCurrentFeedWithDeviations creates a new current feeds with deviations instance
+func NewCurrentFeedWithDeviations(
+	feedWithDeviations []FeedWithDeviation,
+	lastUpdateTimestamp int64,
+	lastUpdateBlock int64,
+) CurrentFeedWithDeviations {
+	return CurrentFeedWithDeviations{
+		Feeds:               feedWithDeviations,
+		LastUpdateTimestamp: lastUpdateTimestamp,
+		LastUpdateBlock:     lastUpdateBlock,
+	}
+}
+
 // CalculateInterval calculates feed interval from power
 func CalculateInterval(power int64, powerStep int64, minInterval int64, maxInterval int64) (interval int64) {
 	if power < powerStep {

x/feeds/types/median.go

@@ -23,6 +23,23 @@ type PriceFeedInfo struct {
 	Index       int64       // Index represents the index of the price feed
 }
 
+// NewPriceFeedInfo returns a new PriceFeedInfo
+func NewPriceFeedInfo(
+	priceStatus PriceStatus,
+	power uint64,
+	price uint64,
+	timestamp int64,
+	index int64,
+) PriceFeedInfo {
+	return PriceFeedInfo{
+		PriceStatus: priceStatus,
+		Power:       power,
+		Price:       price,
+		Timestamp:   timestamp,
+		Index:       index,
+	}
+}
+
 // FilterPriceFeedInfos filters price feed infos based on price status
 func FilterPriceFeedInfos(pfInfos []PriceFeedInfo, opt PriceStatus) []PriceFeedInfo {
 	filtered := []PriceFeedInfo{}