feat: Add percentage decision policy to x/group

proto/cosmos/group/v1beta1/types.proto

@@ -46,6 +46,18 @@ message ThresholdDecisionPolicy {
   google.protobuf.Duration timeout = 2 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];
 }
 
+// PercentageDecisionPolicy implements the DecisionPolicy interface
+message PercentageDecisionPolicy {
+  option (cosmos_proto.implements_interface) = "DecisionPolicy";
+
+  // percentage is the minimum threshold percentage the weighted sum of yes votes must met for a proposal to succeed.
+  string percentage = 1;
+
+  // timeout is the duration from submission of a proposal to the end of voting period
+  // Within this times votes and exec messages can be submitted.
+  google.protobuf.Duration timeout = 2 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];
+}
+
 // Choice defines available types of choices for voting.
 enum Choice {
 

x/group/client/cli/tx.go

@@ -299,6 +299,9 @@ Note, the '--from' flag is ignored as it is implied from [admin].
 Example:
 $ %s tx group create-group-policy [admin] [group-id] [metadata] \
 '{"@type":"/cosmos.group.v1beta1.ThresholdDecisionPolicy", "threshold":"1", "timeout":"1s"}'
+
+Here, we can use percentage decision policy when needed, where percentage varies from 0 to 1.
+Ex: '{"@type":"/cosmos.group.v1beta1.PercentageDecisionPolicy", "percentage":"0.5", "timeout":"1s"}'
 `,
 				version.AppName,
 			),

x/group/client/testutil/query.go

@@ -372,6 +372,7 @@ func (s *IntegrationTestSuite) TestQueryGroupPoliciesByGroup() {
 				s.groupPolicies[2],
 				s.groupPolicies[3],
 				s.groupPolicies[4],
+				s.groupPolicies[5],
 			},
 		},
 	}
@@ -443,6 +444,7 @@ func (s *IntegrationTestSuite) TestQueryGroupPoliciesByAdmin() {
 				s.groupPolicies[2],
 				s.groupPolicies[3],
 				s.groupPolicies[4],
+				s.groupPolicies[5],
 			},
 		},
 	}

x/group/client/testutil/tx.go

@@ -124,10 +124,29 @@ func (s *IntegrationTestSuite) SetupSuite() {
 		out, err = cli.ExecTestCLICmd(val.ClientCtx, client.QueryGroupPoliciesByGroupCmd(), []string{"1", fmt.Sprintf("--%s=json", tmcli.OutputFlag)})
 		s.Require().NoError(err, out.String())
 	}
+	percentage := 0.5
+	// create group policy with percentage decision policy
+	out, err = cli.ExecTestCLICmd(val.ClientCtx, client.MsgCreateGroupPolicyCmd(),
+		append(
+			[]string{
+				val.Address.String(),
+				"1",
+				validMetadata,
+				fmt.Sprintf("{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"%f\", \"timeout\":\"30000s\"}", percentage),
+			},
+			commonFlags...,
+		),
+	)
+	s.Require().NoError(err, out.String())
+	s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &txResp), out.String())
+	s.Require().Equal(uint32(0), txResp.Code, out.String())
+
+	out, err = cli.ExecTestCLICmd(val.ClientCtx, client.QueryGroupPoliciesByGroupCmd(), []string{"1", fmt.Sprintf("--%s=json", tmcli.OutputFlag)})
+	s.Require().NoError(err, out.String())
 
 	var res group.QueryGroupPoliciesByGroupResponse
 	s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res))
-	s.Require().Equal(len(res.GroupPolicies), 5)
+	s.Require().Equal(len(res.GroupPolicies), 6)
 	s.groupPolicies = res.GroupPolicies
 
 	// create a proposal
@@ -706,6 +725,22 @@ func (s *IntegrationTestSuite) TestTxCreateGroupPolicy() {
 			&sdk.TxResponse{},
 			0,
 		},
+		{
+			"correct data with percentage decision policy",
+			append(
+				[]string{
+					val.Address.String(),
+					fmt.Sprintf("%v", groupID),
+					validMetadata,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"0.5\", \"timeout\":\"1s\"}",
+				},
+				commonFlags...,
+			),
+			false,
+			"",
+			&sdk.TxResponse{},
+			0,
+		},
 		{
 			"with amino-json",
 			append(
@@ -771,6 +806,38 @@ func (s *IntegrationTestSuite) TestTxCreateGroupPolicy() {
 			&sdk.TxResponse{},
 			0,
 		},
+		{
+			"invalid percentage decision policy with negative value",
+			append(
+				[]string{
+					val.Address.String(),
+					fmt.Sprintf("%v", groupID),
+					validMetadata,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"-0.5\", \"timeout\":\"1s\"}",
+				},
+				commonFlags...,
+			),
+			true,
+			"expected a positive decimal",
+			&sdk.TxResponse{},
+			0,
+		},
+		{
+			"invalid percentage decision policy with value greater than 1",
+			append(
+				[]string{
+					val.Address.String(),
+					fmt.Sprintf("%v", groupID),
+					validMetadata,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"2\", \"timeout\":\"1s\"}",
+				},
+				commonFlags...,
+			),
+			true,
+			"percentage must be in the range of 0 to 1",
+			&sdk.TxResponse{},
+			0,
+		},
 	}
 
 	for _, tc := range testCases {
@@ -931,6 +998,21 @@ func (s *IntegrationTestSuite) TestTxUpdateGroupPolicyDecisionPolicy() {
 			&sdk.TxResponse{},
 			0,
 		},
+		{
+			"correct data with percentage decision policy",
+			append(
+				[]string{
+					groupPolicy.Admin,
+					groupPolicy.Address,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"0.5\", \"timeout\":\"40000s\"}",
+				},
+				commonFlags...,
+			),
+			false,
+			"",
+			&sdk.TxResponse{},
+			0,
+		},
 		{
 			"with amino-json",
 			append(
@@ -977,6 +1059,36 @@ func (s *IntegrationTestSuite) TestTxUpdateGroupPolicyDecisionPolicy() {
 			&sdk.TxResponse{},
 			0,
 		},
+		{
+			"invalid percentage decision policy with negative value",
+			append(
+				[]string{
+					groupPolicy.Admin,
+					groupPolicy.Address,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"-0.5\", \"timeout\":\"1s\"}",
+				},
+				commonFlags...,
+			),
+			true,
+			"expected a positive decimal",
+			&sdk.TxResponse{},
+			0,
+		},
+		{
+			"invalid percentage decision policy with value greater than 1",
+			append(
+				[]string{
+					groupPolicy.Admin,
+					groupPolicy.Address,
+					"{\"@type\":\"/cosmos.group.v1beta1.PercentageDecisionPolicy\", \"percentage\":\"2\", \"timeout\":\"40000s\"}",
+				},
+				commonFlags...,
+			),
+			true,
+			"percentage must be in the range of 0 to 1",
+			&sdk.TxResponse{},
+			0,
+		},
 	}
 
 	for _, tc := range testCases {

x/group/codec.go

@@ -13,6 +13,7 @@ import (
 func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterInterface((*DecisionPolicy)(nil), nil)
 	cdc.RegisterConcrete(&ThresholdDecisionPolicy{}, "cosmos-sdk/ThresholdDecisionPolicy", nil)
+	cdc.RegisterConcrete(&PercentageDecisionPolicy{}, "cosmos-sdk/PercentageDecisionPolicy", nil)
 	cdc.RegisterConcrete(&MsgCreateGroup{}, "cosmos-sdk/MsgCreateGroup", nil)
 	cdc.RegisterConcrete(&MsgUpdateGroupMembers{}, "cosmos-sdk/MsgUpdateGroupMembers", nil)
 	cdc.RegisterConcrete(&MsgUpdateGroupAdmin{}, "cosmos-sdk/MsgUpdateGroupAdmin", nil)
@@ -47,6 +48,7 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 		"cosmos.group.v1beta1.DecisionPolicy",
 		(*DecisionPolicy)(nil),
 		&ThresholdDecisionPolicy{},
+		&PercentageDecisionPolicy{},
 	)
 }
 

x/group/internal/math/dec.go

@@ -84,6 +84,10 @@ func (x Dec) Int64() (int64, error) {
 	return x.dec.Int64()
 }
 
+func (x Dec) Float64() (float64, error) {
+	return x.dec.Float64()
+}
+
 func (x Dec) Cmp(y Dec) int {
 	return x.dec.Cmp(&y.dec)
 }
@@ -101,6 +105,21 @@ func Add(x Dec, y Dec) (Dec, error) {
 	return x.Add(y)
 }
 
+var dec128Context = apd.Context{
+	Precision:   34,
+	MaxExponent: apd.MaxExponent,
+	MinExponent: apd.MinExponent,
+	Traps:       apd.DefaultTraps,
+}
+
+// Quo returns a new Dec with value `x/y` (formatted as decimal128, 34 digit precision) without mutating any
+// argument and error if there is an overflow.
+func (x Dec) Quo(y Dec) (Dec, error) {
+	var z Dec
+	_, err := dec128Context.Quo(&z.dec, &x.dec, &y.dec)
+	return z, sdkerrors.Wrap(err, "decimal quotient error")
+}
+
 func (x Dec) IsZero() bool {
 	return x.dec.IsZero()
 }

x/group/keeper/keeper_test.go

@@ -719,9 +719,10 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 	myGroupID := groupRes.GroupId
 
 	specs := map[string]struct {
-		req    *group.MsgCreateGroupPolicy
-		policy group.DecisionPolicy
-		expErr bool
+		req       *group.MsgCreateGroupPolicy
+		policy    group.DecisionPolicy
+		expErr    bool
+		expErrMsg string
 	}{
 		"all good": {
 			req: &group.MsgCreateGroupPolicy{
@@ -734,6 +735,17 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 				time.Second,
 			),
 		},
+		"all good with percentage decision policy": {
+			req: &group.MsgCreateGroupPolicy{
+				Admin:    addr1.String(),
+				Metadata: nil,
+				GroupId:  myGroupID,
+			},
+			policy: group.NewPercentageDecisionPolicy(
+				"0.5",
+				time.Second,
+			),
+		},
 		"decision policy threshold > total group weight": {
 			req: &group.MsgCreateGroupPolicy{
 				Admin:    addr1.String(),
@@ -755,7 +767,8 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 				"1",
 				time.Second,
 			),
-			expErr: true,
+			expErr:    true,
+			expErrMsg: "not found",
 		},
 		"admin not group admin": {
 			req: &group.MsgCreateGroupPolicy{
@@ -767,7 +780,8 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 				"1",
 				time.Second,
 			),
-			expErr: true,
+			expErr:    true,
+			expErrMsg: "not group admin",
 		},
 		"metadata too long": {
 			req: &group.MsgCreateGroupPolicy{
@@ -779,7 +793,34 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 				"1",
 				time.Second,
 			),
-			expErr: true,
+			expErr:    true,
+			expErrMsg: "limit exceeded",
+		},
+		"percentage decision policy with negative value": {
+			req: &group.MsgCreateGroupPolicy{
+				Admin:    addr1.String(),
+				Metadata: nil,
+				GroupId:  myGroupID,
+			},
+			policy: group.NewPercentageDecisionPolicy(
+				"-0.5",
+				time.Second,
+			),
+			expErr:    true,
+			expErrMsg: "expected a positive decimal",
+		},
+		"percentage decision policy with value greater than 1": {
+			req: &group.MsgCreateGroupPolicy{
+				Admin:    addr1.String(),
+				Metadata: nil,
+				GroupId:  myGroupID,
+			},
+			policy: group.NewPercentageDecisionPolicy(
+				"2",
+				time.Second,
+			),
+			expErr:    true,
+			expErrMsg: "percentage must be in the range of 0 to 1",
 		},
 	}
 	for msg, spec := range specs {
@@ -791,6 +832,7 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 			res, err := s.keeper.CreateGroupPolicy(s.ctx, spec.req)
 			if spec.expErr {
 				s.Require().Error(err)
+				s.Require().Contains(err.Error(), spec.expErrMsg)
 				return
 			}
 			s.Require().NoError(err)
@@ -806,7 +848,6 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 			s.Assert().Equal(spec.req.Admin, groupPolicy.Admin)
 			s.Assert().Equal(spec.req.Metadata, groupPolicy.Metadata)
 			s.Assert().Equal(uint64(1), groupPolicy.Version)
-			s.Assert().Equal(spec.policy.(*group.ThresholdDecisionPolicy), groupPolicy.GetDecisionPolicy())
 		})
 	}
 }
@@ -1029,6 +1070,26 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() {
 			},
 			expErr: false,
 		},
+		"correct data with percentage decision policy": {
+			req: &group.MsgUpdateGroupPolicyDecisionPolicy{
+				Admin:   admin.String(),
+				Address: groupPolicyAddr,
+			},
+			policy: group.NewPercentageDecisionPolicy(
+				"0.5",
+				time.Duration(2)*time.Second,
+			),
+			expGroupPolicy: &group.GroupPolicyInfo{
+				Admin:          admin.String(),
+				Address:        groupPolicyAddr,
+				GroupId:        myGroupID,
+				Metadata:       nil,
+				Version:        3,
+				DecisionPolicy: nil,
+				CreatedAt:      s.blockTime,
+			},
+			expErr: false,
+		},
 	}
 	for msg, spec := range specs {
 		spec := spec
@@ -1076,9 +1137,13 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
 			"10",
 			time.Second,
 		),
+		group.NewPercentageDecisionPolicy(
+			"0.5",
+			time.Second,
+		),
 	}
 
-	count := 2
+	count := 3
 	expectAccs := make([]*group.GroupPolicyInfo, count)
 	for i := range expectAccs {
 		req := &group.MsgCreateGroupPolicy{