From d764401bdf53a47d315a0270070e676aa600b260 Mon Sep 17 00:00:00 2001 From: Shogo Hyodo Date: Fri, 12 May 2023 16:08:29 +0900 Subject: [PATCH] Implement the logic of Challenge query --- simapp/app.go | 13 ++ x/or/settlement/client/cli/query.go | 20 ++- x/or/settlement/client/cli/tx.go | 36 ++++- x/or/settlement/keeper/challenge.go | 31 ++++ x/or/settlement/keeper/challenge_test.go | 36 +++++ x/or/settlement/keeper/grpc_query.go | 19 ++- x/or/settlement/keeper/grpc_query_test.go | 46 ++++++ x/or/settlement/keeper/keeper.go | 4 +- x/or/settlement/keeper/keeper_test.go | 41 ++++++ x/or/settlement/keeper/key.go | 20 +++ x/or/settlement/keeper/params.go | 29 ++++ x/or/settlement/testutil/keeper/settlement.go | 2 +- x/or/settlement/types/codec.go | 25 +++- x/or/settlement/types/errors.go | 2 +- x/or/settlement/types/msgs.go | 137 ++++++++++++++++++ x/or/settlement/types/params.go | 18 +++ 16 files changed, 459 insertions(+), 20 deletions(-) create mode 100644 x/or/settlement/keeper/challenge.go create mode 100644 x/or/settlement/keeper/challenge_test.go create mode 100644 x/or/settlement/keeper/grpc_query_test.go create mode 100644 x/or/settlement/keeper/keeper_test.go create mode 100644 x/or/settlement/keeper/key.go create mode 100644 x/or/settlement/keeper/params.go create mode 100644 x/or/settlement/types/msgs.go create mode 100644 x/or/settlement/types/params.go diff --git a/simapp/app.go b/simapp/app.go index 7fb5602fb3..38462eee97 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -81,6 +81,9 @@ import ( "github.com/Finschia/finschia-sdk/x/mint" mintkeeper "github.com/Finschia/finschia-sdk/x/mint/keeper" minttypes "github.com/Finschia/finschia-sdk/x/mint/types" + "github.com/Finschia/finschia-sdk/x/or/settlement" + settlementkeeper "github.com/Finschia/finschia-sdk/x/or/settlement/keeper" + settlementtypes "github.com/Finschia/finschia-sdk/x/or/settlement/types" "github.com/Finschia/finschia-sdk/x/params" paramsclient "github.com/Finschia/finschia-sdk/x/params/client" paramskeeper "github.com/Finschia/finschia-sdk/x/params/keeper" @@ -142,6 +145,7 @@ var ( vesting.AppModuleBasic{}, tokenmodule.AppModuleBasic{}, collectionmodule.AppModuleBasic{}, + settlement.AppModuleBasic{}, ) // module account permissions @@ -201,6 +205,7 @@ type SimApp struct { ClassKeeper classkeeper.Keeper TokenKeeper tokenkeeper.Keeper CollectionKeeper collectionkeeper.Keeper + SettlementKeeper settlementkeeper.Keeper // the module manager mm *module.Manager @@ -254,6 +259,7 @@ func NewSimApp( token.StoreKey, collection.StoreKey, authzkeeper.StoreKey, + settlementtypes.StoreKey, ) tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey) // NOTE: The testingkey is just mounted for testing purposes. Actual applications should @@ -322,6 +328,8 @@ func NewSimApp( app.TokenKeeper = tokenkeeper.NewKeeper(appCodec, keys[token.StoreKey], app.ClassKeeper) app.CollectionKeeper = collectionkeeper.NewKeeper(appCodec, keys[collection.StoreKey], app.ClassKeeper) + app.SettlementKeeper = settlementkeeper.NewKeeper(appCodec, keys[settlementtypes.StoreKey], keys[settlementtypes.MemStoreKey]) + // register the staking hooks // NOTE: stakingKeeper above is passed by reference, so that it will contain these hooks app.StakingKeeper = *stakingKeeper.SetHooks( @@ -387,6 +395,7 @@ func NewSimApp( tokenmodule.NewAppModule(appCodec, app.TokenKeeper), collectionmodule.NewAppModule(appCodec, app.CollectionKeeper), authzmodule.NewAppModule(appCodec, app.AuthzKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry), + settlement.NewAppModule(appCodec, app.SettlementKeeper, app.AccountKeeper, app.BankKeeper), ) // During begin block slashing happens after distr.BeginBlocker so that @@ -414,6 +423,7 @@ func NewSimApp( vestingtypes.ModuleName, token.ModuleName, collection.ModuleName, + settlementtypes.ModuleName, ) app.mm.SetOrderEndBlockers( crisistypes.ModuleName, @@ -435,6 +445,7 @@ func NewSimApp( foundation.ModuleName, token.ModuleName, collection.ModuleName, + settlementtypes.ModuleName, ) // NOTE: The genutils module must occur after staking so that pools are @@ -462,6 +473,7 @@ func NewSimApp( vestingtypes.ModuleName, token.ModuleName, collection.ModuleName, + settlementtypes.ModuleName, ) // Uncomment if you want to set a custom migration order here. @@ -712,6 +724,7 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino paramsKeeper.Subspace(slashingtypes.ModuleName) paramsKeeper.Subspace(govtypes.ModuleName).WithKeyTable(govtypes.ParamKeyTable()) paramsKeeper.Subspace(crisistypes.ModuleName) + paramsKeeper.Subspace(settlementtypes.ModuleName) return paramsKeeper } diff --git a/x/or/settlement/client/cli/query.go b/x/or/settlement/client/cli/query.go index de5ee4299f..aeb71ead0c 100644 --- a/x/or/settlement/client/cli/query.go +++ b/x/or/settlement/client/cli/query.go @@ -3,6 +3,7 @@ package cli import ( "context" "fmt" + "strconv" // "strings" @@ -10,6 +11,7 @@ import ( "github.com/Finschia/finschia-sdk/client" "github.com/Finschia/finschia-sdk/client/flags" + "github.com/Finschia/finschia-sdk/version" // "github.com/Finschia/finschia-sdk/client/flags" // sdk "github.com/Finschia/finschia-sdk/types" @@ -35,15 +37,23 @@ func GetQueryCmd(queryRoute string) *cobra.Command { func NewQueryCmdChallenge() *cobra.Command { cmd := &cobra.Command{ - Use: "challenge", - Short: "shows the challenge of the module", - Args: cobra.NoArgs, + Use: "challenge", + Short: "shows the challenge of the module", + Args: cobra.ExactArgs(1), + Example: fmt.Sprintf(`$ %s query %s challenge `, version.AppName, types.ModuleName), RunE: func(cmd *cobra.Command, args []string) error { clientCtx := client.GetClientContextFromCmd(cmd) - queryClient := types.NewQueryClient(clientCtx) - res, err := queryClient.Challenge(context.Background(), &types.QueryChallengeRequest{}) + ci, err := strconv.ParseInt(args[0], 10, 64) + if err != nil { + return err + } + + req := &types.QueryChallengeRequest{ + ChallengeId: ci, + } + res, err := queryClient.Challenge(context.Background(), req) if err != nil { return err } diff --git a/x/or/settlement/client/cli/tx.go b/x/or/settlement/client/cli/tx.go index 8d0a79eb74..037604b781 100644 --- a/x/or/settlement/client/cli/tx.go +++ b/x/or/settlement/client/cli/tx.go @@ -36,25 +36,49 @@ func GetTxCmd() *cobra.Command { } func NewTxCmdInitiateChallenge() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } func NewTxCmdProposeState() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } func NewTxCmdRespondState() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } func NewTxCmdConfirmStateTransition() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } func NewTxCmdDenyStateTransition() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } func NewTxCmdAddTrieNode() *cobra.Command { - panic("implement me") + return &cobra.Command{ + RunE: func(cmd *cobra.Command, args []string) error { + panic("implement me") + }, + } } diff --git a/x/or/settlement/keeper/challenge.go b/x/or/settlement/keeper/challenge.go new file mode 100644 index 0000000000..18d37ec768 --- /dev/null +++ b/x/or/settlement/keeper/challenge.go @@ -0,0 +1,31 @@ +package keeper + +import ( + sdk "github.com/Finschia/finschia-sdk/types" + "github.com/Finschia/finschia-sdk/x/or/settlement/types" +) + +func (k Keeper) SetChallenge(ctx sdk.Context, challengeID int64, challenge types.Challenge) { + store := ctx.KVStore(k.storeKey) + key := challengeKey(challengeID) + + bz, err := challenge.Marshal() + if err != nil { + panic(err) + } + store.Set(key, bz) +} + +func (k Keeper) GetChallenge(ctx sdk.Context, challengeID int64) (*types.Challenge, error) { + store := ctx.KVStore(k.storeKey) + key := challengeKey(challengeID) + bz := store.Get(key) + if bz == nil { + return nil, types.ErrChallengeNotExist.Wrapf("no challenge for %d", challengeID) + } + + var challenge types.Challenge + k.cdc.MustUnmarshal(bz, &challenge) + + return &challenge, nil +} diff --git a/x/or/settlement/keeper/challenge_test.go b/x/or/settlement/keeper/challenge_test.go new file mode 100644 index 0000000000..cdae4294ee --- /dev/null +++ b/x/or/settlement/keeper/challenge_test.go @@ -0,0 +1,36 @@ +package keeper_test + +import ( + "github.com/Finschia/finschia-sdk/x/or/settlement/types" +) + +func (s *KeeperTestSuite) TestGetChallenge() { + testCases := map[string]struct { + challengeID int64 + expected *types.Challenge + err error + }{ + "valid request": { + challengeID: 1, + expected: &types.Challenge{}, + }, + "not found (not existing challenge id)": { + challengeID: 2, + err: types.ErrChallengeNotExist, + }, + } + + for name, tc := range testCases { + s.Run(name, func() { + if tc.expected != nil { + s.app.SettlementKeeper.SetChallenge(s.ctx, tc.challengeID, *tc.expected) + } + challenge, err := s.app.SettlementKeeper.GetChallenge(s.ctx, tc.challengeID) + s.Require().ErrorIs(err, tc.err) + if tc.err != nil { + return + } + s.Require().Equal(tc.expected, challenge) + }) + } +} diff --git a/x/or/settlement/keeper/grpc_query.go b/x/or/settlement/keeper/grpc_query.go index 2d2b583543..458e897b82 100644 --- a/x/or/settlement/keeper/grpc_query.go +++ b/x/or/settlement/keeper/grpc_query.go @@ -3,11 +3,26 @@ package keeper import ( "context" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + sdk "github.com/Finschia/finschia-sdk/types" "github.com/Finschia/finschia-sdk/x/or/settlement/types" ) var _ types.QueryServer = Keeper{} -func (k Keeper) Challenge(ctx context.Context, req *types.QueryChallengeRequest) (*types.QueryChallengeResponse, error) { - panic("implement me") +func (k Keeper) Challenge(c context.Context, req *types.QueryChallengeRequest) (*types.QueryChallengeResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + challenge, err := k.GetChallenge(ctx, req.ChallengeId) + + if err != nil { + return nil, status.Error(codes.NotFound, err.Error()) + } + + return &types.QueryChallengeResponse{Challenge: challenge}, err } diff --git a/x/or/settlement/keeper/grpc_query_test.go b/x/or/settlement/keeper/grpc_query_test.go new file mode 100644 index 0000000000..9a24cd2969 --- /dev/null +++ b/x/or/settlement/keeper/grpc_query_test.go @@ -0,0 +1,46 @@ +package keeper_test + +import ( + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + sdk "github.com/Finschia/finschia-sdk/types" + "github.com/Finschia/finschia-sdk/x/or/settlement/types" +) + +func (s *KeeperTestSuite) TestChallenge() { + ctx := sdk.WrapSDKContext(s.ctx) + + testCases := map[string]struct { + req *types.QueryChallengeRequest + expectedRes *types.QueryChallengeResponse + err error + }{ + "valid request": { + req: &types.QueryChallengeRequest{ChallengeId: 1}, + expectedRes: &types.QueryChallengeResponse{Challenge: &types.Challenge{}}, + }, + "nil request": { + err: status.Error(codes.InvalidArgument, "empty request"), + }, + "non-existent challenge id": { + req: &types.QueryChallengeRequest{ChallengeId: 2}, + err: status.Error(codes.NotFound, types.ErrChallengeNotExist.Wrapf("no challenge for %d", 2).Error()), + }, + } + + for name, tc := range testCases { + s.Run(name, func() { + if tc.expectedRes != nil { + s.app.SettlementKeeper.SetChallenge(s.ctx, tc.req.ChallengeId, *tc.expectedRes.Challenge) + } + res, err := s.app.SettlementKeeper.Challenge(ctx, tc.req) + if tc.err != nil { + s.Require().EqualError(tc.err, err.Error()) + return + } + s.Require().NoError(err) + s.Require().Equal(tc.expectedRes, res) + }) + } +} diff --git a/x/or/settlement/keeper/keeper.go b/x/or/settlement/keeper/keeper.go index a33d9906e8..62a58e6664 100644 --- a/x/or/settlement/keeper/keeper.go +++ b/x/or/settlement/keeper/keeper.go @@ -22,8 +22,8 @@ func NewKeeper( cdc codec.BinaryCodec, storeKey, memKey sdk.StoreKey, -) *Keeper { - return &Keeper{ +) Keeper { + return Keeper{ cdc: cdc, storeKey: storeKey, memKey: memKey, diff --git a/x/or/settlement/keeper/keeper_test.go b/x/or/settlement/keeper/keeper_test.go new file mode 100644 index 0000000000..3e00fd4436 --- /dev/null +++ b/x/or/settlement/keeper/keeper_test.go @@ -0,0 +1,41 @@ +package keeper_test + +import ( + "testing" + + "github.com/stretchr/testify/suite" + + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + + "github.com/Finschia/finschia-sdk/baseapp" + "github.com/Finschia/finschia-sdk/simapp" + sdk "github.com/Finschia/finschia-sdk/types" + "github.com/Finschia/finschia-sdk/x/or/settlement/types" +) + +type KeeperTestSuite struct { + suite.Suite + + app *simapp.SimApp + ctx sdk.Context + + queryClient types.QueryClient +} + +func (s *KeeperTestSuite) SetupTest() { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, tmproto.Header{}) + app.SettlementKeeper.SetParams(ctx, types.DefaultParams()) + + queryHelper := baseapp.NewQueryServerTestHelper(s.ctx, app.InterfaceRegistry()) + types.RegisterQueryServer(queryHelper, app.SettlementKeeper) + queryClient := types.NewQueryClient(queryHelper) + + s.app = app + s.ctx = ctx + s.queryClient = queryClient +} + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(KeeperTestSuite)) +} diff --git a/x/or/settlement/keeper/key.go b/x/or/settlement/keeper/key.go new file mode 100644 index 0000000000..6d7442824f --- /dev/null +++ b/x/or/settlement/keeper/key.go @@ -0,0 +1,20 @@ +package keeper + +import ( + "encoding/binary" +) + +var ( + paramsKeyPrefix = []byte{0x00} + challengeKeyPrefix = []byte{0x01} +) + +func paramsKey() []byte { + return paramsKeyPrefix +} + +func challengeKey(challengID int64) []byte { + b := make([]byte, 8) + binary.LittleEndian.PutUint64(b, uint64(challengID)) + return append(challengeKeyPrefix, b...) +} diff --git a/x/or/settlement/keeper/params.go b/x/or/settlement/keeper/params.go new file mode 100644 index 0000000000..e31b94c02f --- /dev/null +++ b/x/or/settlement/keeper/params.go @@ -0,0 +1,29 @@ +package keeper + +import ( + sdk "github.com/Finschia/finschia-sdk/types" + "github.com/Finschia/finschia-sdk/x/or/settlement/types" +) + +// GetParams get all parameters as types.Params +func (k Keeper) GetParams(ctx sdk.Context) (types.Params, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(paramsKey()) + var params types.Params + if bz == nil { + return params, nil + } + err := k.cdc.Unmarshal(bz, ¶ms) + return params, err +} + +// SetParams set the params +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error { + store := ctx.KVStore(k.storeKey) + bz, err := k.cdc.Marshal(¶ms) + if err != nil { + return err + } + store.Set(paramsKey(), bz) + return nil +} diff --git a/x/or/settlement/testutil/keeper/settlement.go b/x/or/settlement/testutil/keeper/settlement.go index 3ac0e6c633..b75b859161 100644 --- a/x/or/settlement/testutil/keeper/settlement.go +++ b/x/or/settlement/testutil/keeper/settlement.go @@ -37,5 +37,5 @@ func SettlementKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) { ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger()) - return k, ctx + return &k, ctx } diff --git a/x/or/settlement/types/codec.go b/x/or/settlement/types/codec.go index 3d8bc224d0..448ce80ee8 100644 --- a/x/or/settlement/types/codec.go +++ b/x/or/settlement/types/codec.go @@ -2,18 +2,37 @@ package types import ( "github.com/Finschia/finschia-sdk/codec" + "github.com/Finschia/finschia-sdk/codec/legacy" cdctypes "github.com/Finschia/finschia-sdk/codec/types" - // this line is used by starport scaffolding # 1 + sdk "github.com/Finschia/finschia-sdk/types" "github.com/Finschia/finschia-sdk/types/msgservice" ) func RegisterCodec(cdc *codec.LegacyAmino) { - // this line is used by starport scaffolding # 2 + legacy.RegisterAminoMsg(cdc, &MsgAddTrieNode{}, "finschia-sdk/MsgAddTrieNode") + legacy.RegisterAminoMsg(cdc, &MsgConfirmStateTransition{}, "finschia-sdk/MsgConfirmStateTransition") + legacy.RegisterAminoMsg(cdc, &MsgDenyStateTransition{}, "finschia-sdk/MsgDenyStateTransition") + legacy.RegisterAminoMsg(cdc, &MsgInitiateChallenge{}, "finschia-sdk/MsgInitiateChallenge") + legacy.RegisterAminoMsg(cdc, &MsgProposeState{}, "finschia-sdk/MsgProposeState") + legacy.RegisterAminoMsg(cdc, &MsgRespondState{}, "finschia-sdk/MsgRespondState") } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { - // this line is used by starport scaffolding # 3 + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgAddTrieNode{}, + &MsgConfirmStateTransition{}, + &MsgDenyStateTransition{}, + &MsgInitiateChallenge{}, + &MsgProposeState{}, + &MsgRespondState{}, + ) + + registry.RegisterInterface( + "finschia.or.settlement.v1.Challenge", + (*interface{})(nil), + &Challenge{}, + ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) } diff --git a/x/or/settlement/types/errors.go b/x/or/settlement/types/errors.go index bd62d930a9..74b4d17c25 100644 --- a/x/or/settlement/types/errors.go +++ b/x/or/settlement/types/errors.go @@ -8,5 +8,5 @@ import ( // x/or/settlement module sentinel errors var ( - ErrSample = sdkerrors.Register(ModuleName, 1100, "sample error") + ErrChallengeNotExist = sdkerrors.Register(ModuleName, 1, "challenge does not exist") ) diff --git a/x/or/settlement/types/msgs.go b/x/or/settlement/types/msgs.go new file mode 100644 index 0000000000..5dea24f80f --- /dev/null +++ b/x/or/settlement/types/msgs.go @@ -0,0 +1,137 @@ +package types + +import ( + sdk "github.com/Finschia/finschia-sdk/types" +) + +var _ sdk.Msg = &MsgAddTrieNode{} + +func (m MsgAddTrieNode) ValidateBasic() error { + panic("implement me") +} + +func (m MsgAddTrieNode) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgAddTrieNode) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgAddTrieNode) Route() string { + return RouterKey +} + +func (m MsgAddTrieNode) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +var _ sdk.Msg = &MsgConfirmStateTransition{} + +func (m MsgConfirmStateTransition) ValidateBasic() error { + panic("implement me") +} + +func (m MsgConfirmStateTransition) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgConfirmStateTransition) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgConfirmStateTransition) Route() string { + return RouterKey +} + +func (m MsgConfirmStateTransition) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +var _ sdk.Msg = &MsgDenyStateTransition{} + +func (m MsgDenyStateTransition) ValidateBasic() error { + panic("implement me") +} + +func (m MsgDenyStateTransition) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgDenyStateTransition) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgDenyStateTransition) Route() string { + return RouterKey +} + +func (m MsgDenyStateTransition) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +var _ sdk.Msg = &MsgInitiateChallenge{} + +func (m MsgInitiateChallenge) ValidateBasic() error { + panic("implement me") +} + +func (m MsgInitiateChallenge) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgInitiateChallenge) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgInitiateChallenge) Route() string { + return RouterKey +} + +func (m MsgInitiateChallenge) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +var _ sdk.Msg = &MsgProposeState{} + +func (m MsgProposeState) ValidateBasic() error { + panic("implement me") +} + +func (m MsgProposeState) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgProposeState) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgProposeState) Route() string { + return RouterKey +} + +func (m MsgProposeState) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +var _ sdk.Msg = &MsgRespondState{} + +func (m MsgRespondState) ValidateBasic() error { + panic("implement me") +} + +func (m MsgRespondState) GetSigners() []sdk.AccAddress { + panic("implement me") +} + +func (m MsgRespondState) Type() string { + return sdk.MsgTypeURL(&m) +} + +func (m MsgRespondState) Route() string { + return RouterKey +} + +func (m MsgRespondState) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} diff --git a/x/or/settlement/types/params.go b/x/or/settlement/types/params.go new file mode 100644 index 0000000000..ab51eb463c --- /dev/null +++ b/x/or/settlement/types/params.go @@ -0,0 +1,18 @@ +package types + +import paramtypes "github.com/Finschia/finschia-sdk/x/params/types" + +// NewParams creates a new parameter configuration for the bank module +func NewParams() Params { + return Params{} +} + +// DefaultParams is the default parameter configuration for the bank module +func DefaultParams() Params { + return Params{} +} + +// ParamSetPairs get the params.ParamSet +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{} +}