chore(data-proxy): add genesis import and export

Part-of: #316

proto/sedachain/data_proxy/v1/genesis.proto

@@ -10,23 +10,23 @@ option go_package = "github.com/sedaprotocol/seda-chain/x/data-proxy/types";
 message GenesisState {
   Params params = 1 [ (gogoproto.nullable) = false ];
 
-  repeated DataProxyConfigs data_proxy_configs = 2
+  repeated DataProxyConfig data_proxy_configs = 2
       [ (gogoproto.nullable) = false ];
 
   repeated FeeUpdateQueueRecord fee_update_queue = 3
       [ (gogoproto.nullable) = false ];
 }
 
 // DataProxyConfigs define the data proxy entries in the registry.
-message DataProxyConfigs {
-  string data_proxy_pubkey = 1;
+message DataProxyConfig {
+  bytes data_proxy_pubkey = 1;
 
   ProxyConfig config = 2;
 }
 
 // FeeUpdateQueueRecord defines an entry in the data proxy update queue.
 message FeeUpdateQueueRecord {
-  string data_proxy_pubkey = 1;
+  bytes data_proxy_pubkey = 1;
 
   int64 update_height = 2;
 }

x/data-proxy/keeper/genesis.go

@@ -1,21 +1,101 @@
 package keeper
 
 import (
+	"cosmossdk.io/collections"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/sedaprotocol/seda-chain/x/data-proxy/types"
 )
 
 // InitGenesis initializes the store based on the given genesis state.
-func (k Keeper) InitGenesis(_ sdk.Context, _ types.GenesisState) {
-	// TODO
+func (k Keeper) InitGenesis(ctx sdk.Context, data types.GenesisState) {
+	if err := k.Params.Set(ctx, data.Params); err != nil {
+		panic(err)
+	}
+
+	for _, dataProxyConfig := range data.DataProxyConfigs {
+		if err := k.DataProxyConfigs.Set(ctx, dataProxyConfig.DataProxyPubkey, *dataProxyConfig.Config); err != nil {
+			panic(err)
+		}
+	}
+
+	for _, feeUpdate := range data.FeeUpdateQueue {
+		if err := k.FeeUpdates.Set(ctx, collections.Join(feeUpdate.UpdateHeight, feeUpdate.DataProxyPubkey)); err != nil {
+			panic(err)
+		}
+	}
 }
 
 // ExportGenesis extracts all data from store to genesis state.
-func (k Keeper) ExportGenesis(_ sdk.Context) types.GenesisState {
+func (k Keeper) ExportGenesis(ctx sdk.Context) types.GenesisState {
 	var gs types.GenesisState
 
-	// TODO
+	params, err := k.Params.Get(ctx)
+	if err != nil {
+		panic(err)
+	}
+	gs.Params = params
+
+	configs, err := k.getAllDataProxyConfigs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	gs.DataProxyConfigs = configs
+
+	feeUpdates, err := k.getAllFeeUpdateRecords(ctx)
+	if err != nil {
+		panic(err)
+	}
+	gs.FeeUpdateQueue = feeUpdates
 
 	return gs
 }
+
+func (k Keeper) getAllDataProxyConfigs(ctx sdk.Context) ([]types.DataProxyConfig, error) {
+	configs := make([]types.DataProxyConfig, 0)
+
+	itr, err := k.DataProxyConfigs.Iterate(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer itr.Close()
+
+	for ; itr.Valid(); itr.Next() {
+		kv, err := itr.KeyValue()
+		if err != nil {
+			return nil, err
+		}
+
+		configs = append(configs, types.DataProxyConfig{
+			DataProxyPubkey: kv.Key,
+			Config:          &kv.Value,
+		})
+	}
+
+	return configs, nil
+}
+
+func (k Keeper) getAllFeeUpdateRecords(ctx sdk.Context) ([]types.FeeUpdateQueueRecord, error) {
+	feeUpdates := make([]types.FeeUpdateQueueRecord, 0)
+
+	itr, err := k.FeeUpdates.Iterate(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer itr.Close()
+
+	for ; itr.Valid(); itr.Next() {
+		key, err := itr.Key()
+		if err != nil {
+			return nil, err
+		}
+
+		feeUpdates = append(feeUpdates, types.FeeUpdateQueueRecord{
+			UpdateHeight:    key.K1(),
+			DataProxyPubkey: key.K2(),
+		})
+	}
+
+	return feeUpdates, nil
+}

x/data-proxy/keeper/genesis_test.go

@@ -1,13 +1,56 @@
 package keeper_test
 
 import (
+	"encoding/hex"
+
 	"github.com/sedaprotocol/seda-chain/x/data-proxy/types"
 )
 
 func (s *KeeperTestSuite) TestImportExportGenesis() {
-	genState := types.GenesisState{}
+	pubkeyOne, err := hex.DecodeString("034c0f86f0cb61f9ddb47c4ba0b2ca0470962b5a1c50bee3a563184979672195f4")
+	s.Require().NoError(err)
+
+	pubkeyTwo, err := hex.DecodeString("02100efce2a783cc7a3fbf9c5d15d4cc6e263337651312f21a35d30c16cb38f4c3")
+	s.Require().NoError(err)
+
+	genState := types.GenesisState{
+		Params: types.DefaultParams(),
+		DataProxyConfigs: []types.DataProxyConfig{
+			{
+				DataProxyPubkey: pubkeyOne,
+				Config: &types.ProxyConfig{
+					AdminAddress:  "seda1uea9km4nup9q7qu96ak683kc67x9jf7ste45z5",
+					PayoutAddress: "seda1uea9km4nup9q7qu96ak683kc67x9jf7ste45z5",
+					Fee:           s.NewFeeFromString("5"),
+					Memo:          "",
+					FeeUpdate:     nil,
+				},
+			},
+			{
+				DataProxyPubkey: pubkeyTwo,
+				Config: &types.ProxyConfig{
+					AdminAddress:  "seda1uea9km4nup9q7qu96ak683kc67x9jf7ste45z5",
+					PayoutAddress: "seda1wyzxdtpl0c99c92n397r3drlhj09qfjvf6teyh",
+					Fee:           s.NewFeeFromString("5000"),
+					Memo:          "not my proxy friend",
+					FeeUpdate: &types.FeeUpdate{
+						NewFee:       *s.NewFeeFromString("10000"),
+						UpdateHeight: 500,
+					},
+				},
+			},
+		},
+		FeeUpdateQueue: []types.FeeUpdateQueueRecord{
+			{
+				DataProxyPubkey: pubkeyTwo,
+				UpdateHeight:    500,
+			},
+		},
+	}
 
 	s.keeper.InitGenesis(s.ctx, genState)
-	// exportedGenState := s.keeper.ExportGenesis(s.ctx)
-	// TODO
+	exportedGenState := s.keeper.ExportGenesis(s.ctx)
+	s.Require().Equal(genState.Params, exportedGenState.Params)
+	s.Require().ElementsMatch(genState.DataProxyConfigs, exportedGenState.DataProxyConfigs)
+	s.Require().ElementsMatch(genState.FeeUpdateQueue, exportedGenState.FeeUpdateQueue)
 }

x/data-proxy/types/genesis.go

@@ -1,14 +1,47 @@
 package types
 
-func NewGenesisState() GenesisState {
-	return GenesisState{}
+import "fmt"
+
+func NewGenesisState(params Params, proxyConfigs []DataProxyConfig, feeUpdates []FeeUpdateQueueRecord) GenesisState {
+	return GenesisState{
+		Params:           params,
+		DataProxyConfigs: proxyConfigs,
+		FeeUpdateQueue:   feeUpdates,
+	}
 }
 
 func DefaultGenesisState() *GenesisState {
-	state := NewGenesisState()
+	state := NewGenesisState(DefaultParams(), []DataProxyConfig{}, []FeeUpdateQueueRecord{})
 	return &state
 }
 
-func ValidateGenesis(_ GenesisState) error {
-	return nil
+func ValidateGenesis(data GenesisState) error {
+	for _, proxyConfig := range data.DataProxyConfigs {
+		if len(proxyConfig.DataProxyPubkey) == 0 {
+			return fmt.Errorf("empty public key in proxy configs")
+		}
+
+		if err := proxyConfig.Config.Validate(); err != nil {
+			return err
+		}
+
+		if err := proxyConfig.Config.Fee.Validate(); err != nil {
+			return err
+		}
+
+		if proxyConfig.Config.AdminAddress == "" {
+			return fmt.Errorf("empty admin address")
+		}
+		if proxyConfig.Config.PayoutAddress == "" {
+			return fmt.Errorf("empty payout address")
+		}
+	}
+
+	for _, feeUpdate := range data.FeeUpdateQueue {
+		if len(feeUpdate.DataProxyPubkey) == 0 {
+			return fmt.Errorf("empty public key in fee updates")
+		}
+	}
+
+	return data.Params.Validate()
 }