LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

refactor(group): move ValidateBasic logic to msgServer (#15785)

Browse Source 
Co-authored-by: Marko <marbar3778@yahoo.com>
This commit is contained in:
Julien Robert 2023-04-18 16:26:33 +02:00 committed by GitHub
parent e9e582aede
commit 10d7d15f04
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 3782 additions and 7123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2119
tests/e2e/group/tx.go
View File

File diff suppressed because it is too large Load Diff

5
x/authz/keeper/msg_server.go
View File

@ -5,6 +5,7 @@ import (
"errors"
"strings"
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/x/authz"
@ -120,14 +121,14 @@ func (k Keeper) Exec(goCtx context.Context, msg *authz.MsgExec) (*authz.MsgExecR
}
func validateMsgs(msgs []sdk.Msg) error {
for _, msg := range msgs {
for i, msg := range msgs {
m, ok := msg.(sdk.HasValidateBasic)
if !ok {
continue
}
if err := m.ValidateBasic(); err != nil {
return err
return errorsmod.Wrapf(err, "msg %d", i)
}
}

133
x/group/client/cli/tx.go
View File

@ -4,6 +4,7 @@ import (
"errors"
"fmt"
"strconv"
"strings"
"cosmossdk.io/core/address"
"github.com/spf13/cobra"
@ -13,6 +14,7 @@ import (
"github.com/cosmos/cosmos-sdk/client/tx"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/internal/math"
)
const (
@ -21,6 +23,8 @@ const (
FlagGroupPolicyAsAdmin = "group-policy-as-admin"
)
var errZeroGroupID = errors.New("group id cannot be 0")
// TxCmd returns a root CLI command handler for all x/group transaction commands.
func TxCmd(name string, ac address.Codec) *cobra.Command {
txCmd := &cobra.Command{
@ -95,14 +99,17 @@ Where members.json contains:
return err
}
for _, member := range members {
if _, err := math.NewPositiveDecFromString(member.Weight); err != nil {
return fmt.Errorf("invalid weight %s for %s: weight must be positive", member.Weight, member.Address)
}
}
msg := &group.MsgCreateGroup{
Admin: clientCtx.GetFromAddress().String(),
Members: members,
Metadata: args[1],
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -157,19 +164,26 @@ Set a member's weight to "0" to delete it.
return err
}
for _, member := range members {
if _, err := math.NewNonNegativeDecFromString(member.Weight); err != nil {
return fmt.Errorf("invalid weight %s for %s: weight must not be negative", member.Weight, member.Address)
}
}
groupID, err := strconv.ParseUint(args[1], 10, 64)
if err != nil {
return err
}
if groupID == 0 {
return errZeroGroupID
}
msg := &group.MsgUpdateGroupMembers{
Admin: clientCtx.GetFromAddress().String(),
MemberUpdates: members,
GroupId: groupID,
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -187,8 +201,7 @@ func MsgUpdateGroupAdminCmd() *cobra.Command {
Short: "Update a group's admin",
Args: cobra.ExactArgs(3),
RunE: func(cmd *cobra.Command, args []string) error {
err := cmd.Flags().Set(flags.FlagFrom, args[0])
if err != nil {
if err := cmd.Flags().Set(flags.FlagFrom, args[0]); err != nil {
return err
}
@ -202,14 +215,19 @@ func MsgUpdateGroupAdminCmd() *cobra.Command {
return err
}
if groupID == 0 {
return errZeroGroupID
}
if strings.EqualFold(args[0], args[2]) {
return errors.New("new admin cannot be the same as the current admin")
}
msg := &group.MsgUpdateGroupAdmin{
Admin: clientCtx.GetFromAddress().String(),
NewAdmin: args[2],
GroupId: groupID,
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -242,14 +260,15 @@ func MsgUpdateGroupMetadataCmd() *cobra.Command {
return err
}
if groupID == 0 {
return errZeroGroupID
}
msg := &group.MsgUpdateGroupMetadata{
Admin: clientCtx.GetFromAddress().String(),
Metadata: args[2],
GroupId: groupID,
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -322,11 +341,21 @@ and policy.json contains:
return err
}
for _, member := range members {
if _, err := math.NewPositiveDecFromString(member.Weight); err != nil {
return fmt.Errorf("invalid weight %s for %s: weight must be positive", member.Weight, member.Address)
}
}
policy, err := parseDecisionPolicy(clientCtx.Codec, args[4])
if err != nil {
return err
}
if err := policy.ValidateBasic(); err != nil {
return err
}
msg, err := group.NewMsgCreateGroupWithPolicy(
clientCtx.GetFromAddress().String(),
members,
@ -339,10 +368,6 @@ and policy.json contains:
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
}
@ -398,11 +423,19 @@ Here, we can use percentage decision policy when needed, where 0 < percentage <=
return err
}
if groupID == 0 {
return errZeroGroupID
}
policy, err := parseDecisionPolicy(clientCtx.Codec, args[3])
if err != nil {
return err
}
if err := policy.ValidateBasic(); err != nil {
return err
}
msg, err := group.NewMsgCreateGroupPolicy(
clientCtx.GetFromAddress(),
groupID,
@ -412,9 +445,6 @@ Here, we can use percentage decision policy when needed, where 0 < percentage <=
if err != nil {
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -432,11 +462,14 @@ func MsgUpdateGroupPolicyAdminCmd() *cobra.Command {
Short: "Update a group policy admin",
Args: cobra.ExactArgs(3),
RunE: func(cmd *cobra.Command, args []string) error {
err := cmd.Flags().Set(flags.FlagFrom, args[0])
if err != nil {
if err := cmd.Flags().Set(flags.FlagFrom, args[0]); err != nil {
return err
}
if strings.EqualFold(args[0], args[2]) {
return errors.New("new admin cannot be the same as the current admin")
}
clientCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err
@ -447,9 +480,6 @@ func MsgUpdateGroupPolicyAdminCmd() *cobra.Command {
GroupPolicyAddress: args[1],
NewAdmin: args[2],
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -496,10 +526,6 @@ func MsgUpdateGroupPolicyDecisionPolicyCmd(ac address.Codec) *cobra.Command {
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
}
@ -516,8 +542,7 @@ func MsgUpdateGroupPolicyMetadataCmd() *cobra.Command {
Short: "Update a group policy metadata",
Args: cobra.ExactArgs(3),
RunE: func(cmd *cobra.Command, args []string) error {
err := cmd.Flags().Set(flags.FlagFrom, args[0])
if err != nil {
if err := cmd.Flags().Set(flags.FlagFrom, args[0]); err != nil {
return err
}
@ -531,9 +556,6 @@ func MsgUpdateGroupPolicyMetadataCmd() *cobra.Command {
GroupPolicyAddress: args[1],
Metadata: args[2],
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -611,7 +633,6 @@ metadata example:
}
execStr, _ := cmd.Flags().GetString(FlagExec)
msg, err := group.NewMsgSubmitProposal(
prop.GroupPolicyAddress,
prop.Proposers,
@ -625,10 +646,6 @@ metadata example:
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
}
@ -653,8 +670,7 @@ Parameters:
`,
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
err := cmd.Flags().Set(flags.FlagFrom, args[1])
if err != nil {
if err := cmd.Flags().Set(flags.FlagFrom, args[1]); err != nil {
return err
}
@ -668,19 +684,15 @@ Parameters:
return err
}
if proposalID == 0 {
return fmt.Errorf("invalid proposal id: %d", proposalID)
}
msg := &group.MsgWithdrawProposal{
ProposalId: proposalID,
Address: clientCtx.GetFromAddress().String(),
}
if err != nil {
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
}
@ -739,13 +751,6 @@ Parameters:
Metadata: args[3],
Exec: execFromString(execStr),
}
if err != nil {
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -778,13 +783,6 @@ func MsgExecCmd() *cobra.Command {
ProposalId: proposalID,
Executor: clientCtx.GetFromAddress().String(),
}
if err != nil {
return err
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
@ -820,13 +818,14 @@ Parameters:
return err
}
if groupID == 0 {
return errZeroGroupID
}
msg := &group.MsgLeaveGroup{
Address: clientCtx.GetFromAddress().String(),
GroupId: groupID,
}
if err = msg.ValidateBasic(); err != nil {
return fmt.Errorf("message validation failed: %w", err)
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},

520
x/group/client/cli/tx_test.go
View File

File diff suppressed because it is too large Load Diff

7
x/group/client/cli/util.go
View File

@ -31,7 +31,9 @@ func parseDecisionPolicy(cdc codec.Codec, decisionPolicyFile string) (group.Deci
// parseMembers reads and parses the members.
func parseMembers(membersFile string) ([]group.MemberRequest, error) {
members := group.MemberRequests{}
members := struct {
Members []group.MemberRequest `json:"members"`
}{}
if membersFile == "" {
return members.Members, nil
@ -42,8 +44,7 @@ func parseMembers(membersFile string) ([]group.MemberRequest, error) {
return nil, err
}
err = json.Unmarshal(contents, &members)
if err != nil {
if err := json.Unmarshal(contents, &members); err != nil {
return nil, err
}

2859
x/group/keeper/keeper_test.go
View File

File diff suppressed because it is too large Load Diff

585
x/group/keeper/msg_server.go
View File

File diff suppressed because it is too large Load Diff

3078
x/group/keeper/msg_server_test.go Normal file
View File

File diff suppressed because it is too large Load Diff

308
x/group/msgs.go
View File

@ -11,8 +11,6 @@ import (
"github.com/cosmos/cosmos-sdk/types/tx"
"github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx"
"github.com/cosmos/cosmos-sdk/x/group/codec"
errors "github.com/cosmos/cosmos-sdk/x/group/errors"
"github.com/cosmos/cosmos-sdk/x/group/internal/math"
)
var (
@ -32,34 +30,6 @@ func (m MsgCreateGroup) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgCreateGroup) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
return strictValidateMembers(m.Members)
}
// ValidateBasic performs stateless validation on a group member, such as
// making sure the address is well-formed, and the weight is non-negative.
// Note: in state, a member's weight MUST be positive. However, in some Msgs,
// it's possible to set a zero member weight, for example in
// MsgUpdateGroupMembers to denote that we're removing a member.
func (m MemberRequest) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Address)
if err != nil {
return errorsmod.Wrap(err, "address")
}
if _, err := math.NewNonNegativeDecFromString(m.Weight); err != nil {
return errorsmod.Wrap(err, "weight")
}
return nil
}
var (
_ sdk.Msg = &MsgUpdateGroupAdmin{}
_ legacytx.LegacyMsg = &MsgUpdateGroupAdmin{}
@ -77,28 +47,6 @@ func (m MsgUpdateGroupAdmin) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data.
func (m MsgUpdateGroupAdmin) ValidateBasic() error {
if m.GroupId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "group id")
}
admin, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
newAdmin, err := sdk.AccAddressFromBech32(m.NewAdmin)
if err != nil {
return errorsmod.Wrap(err, "new admin")
}
if admin.Equals(newAdmin) {
return errorsmod.Wrap(errors.ErrInvalid, "new and old admin are the same")
}
return nil
}
// GetGroupID gets the group id of the MsgUpdateGroupAdmin.
func (m *MsgUpdateGroupAdmin) GetGroupID() uint64 {
return m.GroupId
@ -121,19 +69,6 @@ func (m MsgUpdateGroupMetadata) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgUpdateGroupMetadata) ValidateBasic() error {
if m.GroupId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "group id")
}
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
return nil
}
// GetGroupID gets the group id of the MsgUpdateGroupMetadata.
func (m *MsgUpdateGroupMetadata) GetGroupID() uint64 {
return m.GroupId
@ -158,26 +93,6 @@ func (m MsgUpdateGroupMembers) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgUpdateGroupMembers) ValidateBasic() error {
if m.GroupId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "group id")
}
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
if len(m.MemberUpdates) == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "member updates")
}
members := MemberRequests{Members: m.MemberUpdates}
if err := members.ValidateBasic(); err != nil {
return errorsmod.Wrap(err, "members")
}
return nil
}
// GetGroupID gets the group id of the MsgUpdateGroupMembers.
func (m *MsgUpdateGroupMembers) GetGroupID() uint64 {
return m.GroupId
@ -242,23 +157,6 @@ func (m MsgCreateGroupWithPolicy) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgCreateGroupWithPolicy) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
policy, err := m.GetDecisionPolicy()
if err != nil {
return errorsmod.Wrap(err, "decision policy")
}
if err := policy.ValidateBasic(); err != nil {
return errorsmod.Wrap(err, "decision policy")
}
return strictValidateMembers(m.Members)
}
var (
_ sdk.Msg = &MsgCreateGroupPolicy{}
_ legacytx.LegacyMsg = &MsgCreateGroupPolicy{}
@ -275,27 +173,6 @@ func (m MsgCreateGroupPolicy) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgCreateGroupPolicy) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
if m.GroupId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "group id")
}
policy, err := m.GetDecisionPolicy()
if err != nil {
return errorsmod.Wrap(err, "decision policy")
}
if err := policy.ValidateBasic(); err != nil {
return errorsmod.Wrap(err, "decision policy")
}
return nil
}
var (
_ sdk.Msg = &MsgUpdateGroupPolicyAdmin{}
_ legacytx.LegacyMsg = &MsgUpdateGroupPolicyAdmin{}
@ -313,29 +190,6 @@ func (m MsgUpdateGroupPolicyAdmin) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgUpdateGroupPolicyAdmin) ValidateBasic() error {
admin, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
newAdmin, err := sdk.AccAddressFromBech32(m.NewAdmin)
if err != nil {
return errorsmod.Wrap(err, "new admin")
}
_, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress)
if err != nil {
return errorsmod.Wrap(err, "group policy")
}
if admin.Equals(newAdmin) {
return errorsmod.Wrap(errors.ErrInvalid, "new and old admin are same")
}
return nil
}
var (
_ sdk.Msg = &MsgUpdateGroupPolicyDecisionPolicy{}
_ legacytx.LegacyMsg = &MsgUpdateGroupPolicyDecisionPolicy{}
@ -382,30 +236,6 @@ func (m MsgUpdateGroupPolicyDecisionPolicy) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgUpdateGroupPolicyDecisionPolicy) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
_, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress)
if err != nil {
return errorsmod.Wrap(err, "group policy")
}
policy, err := m.GetDecisionPolicy()
if err != nil {
return errorsmod.Wrap(err, "decision policy")
}
if err := policy.ValidateBasic(); err != nil {
return errorsmod.Wrap(err, "decision policy")
}
return nil
}
// GetDecisionPolicy gets the decision policy of MsgUpdateGroupPolicyDecisionPolicy.
func (m *MsgUpdateGroupPolicyDecisionPolicy) GetDecisionPolicy() (DecisionPolicy, error) {
decisionPolicy, ok := m.DecisionPolicy.GetCachedValue().(DecisionPolicy)
@ -439,21 +269,6 @@ func (m MsgUpdateGroupPolicyMetadata) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgUpdateGroupPolicyMetadata) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Admin)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
_, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress)
if err != nil {
return errorsmod.Wrap(err, "group policy")
}
return nil
}
var (
_ sdk.Msg = &MsgCreateGroupPolicy{}
_ legacytx.LegacyMsg = &MsgCreateGroupPolicy{}
@ -552,54 +367,6 @@ func (m MsgSubmitProposal) GetSigners() []sdk.AccAddress {
return addrs
}
// ValidateBasic does a sanity check on the provided proposal, such as
// verifying proposer addresses, and performing ValidateBasic on each
// individual `sdk.Msg`.
func (m MsgSubmitProposal) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.GroupPolicyAddress)
if err != nil {
return errorsmod.Wrap(err, "group policy")
}
if m.Title == "" {
return errorsmod.Wrap(errors.ErrEmpty, "title")
}
if m.Summary == "" {
return errorsmod.Wrap(errors.ErrEmpty, "summary")
}
if len(m.Proposers) == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "proposers")
}
addrs, err := m.getProposerAccAddresses()
if err != nil {
return errorsmod.Wrap(err, "group proposers")
}
if err := accAddresses(addrs).ValidateBasic(); err != nil {
return errorsmod.Wrap(err, "proposers")
}
msgs, err := m.GetMsgs()
if err != nil {
return err
}
for i, msg := range msgs {
m, ok := msg.(sdk.HasValidateBasic)
if !ok {
continue
}
if err := m.ValidateBasic(); err != nil {
return errorsmod.Wrapf(err, "msg %d", i)
}
}
return nil
}
// getProposerAccAddresses returns the proposers as `[]sdk.AccAddress`.
func (m *MsgSubmitProposal) getProposerAccAddresses() ([]sdk.AccAddress, error) {
addrs := make([]sdk.AccAddress, len(m.Proposers))
@ -651,20 +418,6 @@ func (m MsgWithdrawProposal) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{admin}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgWithdrawProposal) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Address)
if err != nil {
return errorsmod.Wrap(err, "admin")
}
if m.ProposalId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "proposal id")
}
return nil
}
var (
_ sdk.Msg = &MsgVote{}
_ legacytx.LegacyMsg = &MsgVote{}
@ -682,24 +435,6 @@ func (m MsgVote) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{addr}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgVote) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Voter)
if err != nil {
return errorsmod.Wrap(err, "voter")
}
if m.ProposalId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "proposal id")
}
if m.Option == VOTE_OPTION_UNSPECIFIED {
return errorsmod.Wrap(errors.ErrEmpty, "vote option")
}
if _, ok := VoteOption_name[int32(m.Option)]; !ok {
return errorsmod.Wrap(errors.ErrInvalid, "vote option")
}
return nil
}
var (
_ sdk.Msg = &MsgExec{}
_ legacytx.LegacyMsg = &MsgExec{}
@ -717,18 +452,6 @@ func (m MsgExec) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{signer}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgExec) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Executor)
if err != nil {
return errorsmod.Wrap(err, "signer")
}
if m.ProposalId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "proposal id")
}
return nil
}
var (
_ sdk.Msg = &MsgLeaveGroup{}
_ legacytx.LegacyMsg = &MsgLeaveGroup{}
@ -745,34 +468,3 @@ func (m MsgLeaveGroup) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{signer}
}
// ValidateBasic does a sanity check on the provided data
func (m MsgLeaveGroup) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(m.Address)
if err != nil {
return errorsmod.Wrap(err, "group member")
}
if m.GroupId == 0 {
return errorsmod.Wrap(errors.ErrEmpty, "group-id")
}
return nil
}
// strictValidateMembers performs ValidateBasic on Members, but also checks
// that all members weights are positive (whereas `Members{members}.ValidateBasic()`
// only checks that they are non-negative.
func strictValidateMembers(members []MemberRequest) error {
err := MemberRequests{members}.ValidateBasic()
if err != nil {
return err
}
for _, m := range members {
if _, err := math.NewPositiveDecFromString(m.Weight); err != nil {
return errorsmod.Wrap(err, "weight")
}
}
return nil
}

1232
x/group/msgs_test.go
View File

File diff suppressed because it is too large Load Diff

10
x/group/types.go
View File

@ -364,10 +364,14 @@ func (g GroupMember) ValidateBasic() error {
return errorsmod.Wrap(errors.ErrEmpty, "group member's group id")
}
err := MemberToMemberRequest(g.Member).ValidateBasic()
if err != nil {
return errorsmod.Wrap(err, "group member")
if _, err := sdk.AccAddressFromBech32(g.Member.Address); err != nil {
return errorsmod.Wrap(err, "group member's address")
}
if _, err := math.NewNonNegativeDecFromString(g.Member.Weight); err != nil {
return errorsmod.Wrap(err, "weight must be non negative")
}
return nil
}

49
x/group/typesupport.go
View File

@ -1,49 +0,0 @@
package group
import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/group/errors"
)
// MemberRequests defines a repeated slice of MemberRequest objects.
type MemberRequests struct {
Members []MemberRequest
}
// ValidateBasic performs stateless validation on an array of members. On top
// of validating each member individually, it also makes sure there are no
// duplicate addresses.
func (ms MemberRequests) ValidateBasic() error {
index := make(map[string]struct{}, len(ms.Members))
for i := range ms.Members {
member := ms.Members[i]
if err := member.ValidateBasic(); err != nil {
return err
}
addr := member.Address
if _, exists := index[addr]; exists {
return errorsmod.Wrapf(errors.ErrDuplicate, "address: %s", addr)
}
index[addr] = struct{}{}
}
return nil
}
type accAddresses []sdk.AccAddress
// ValidateBasic verifies that there's no duplicate address.
// Individual account address validation has to be done separately.
func (a accAddresses) ValidateBasic() error {
index := make(map[string]struct{}, len(a))
for i := range a {
accAddr := a[i]
addr := string(accAddr)
if _, exists := index[addr]; exists {
return errorsmod.Wrapf(errors.ErrDuplicate, "address: %s", accAddr.String())
}
index[addr] = struct{}{}
}
return nil
}