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 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 0 < percentage <= 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 > 0 and <= 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 > 0 and <= 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/internal/math/dec_test.go

@@ -75,6 +75,10 @@ func TestDec(t *testing.T) {
 	require.NoError(t, err)
 	require.True(t, res.IsEqual(minusFivePointZero))
 
+	res, err = four.Quo(two)
+	require.NoError(t, err)
+	require.True(t, res.IsEqual(two))
+
 	require.False(t, zero.IsNegative())
 	require.False(t, one.IsNegative())
 	require.True(t, minusOne.IsNegative())