diff --git a/proto/exocore/oracle/params.proto b/proto/exocore/oracle/params.proto
index 041bf06d2..d2c4a3f95 100644
--- a/proto/exocore/oracle/params.proto
+++ b/proto/exocore/oracle/params.proto
@@ -17,7 +17,7 @@ message Params {
   // sources info from where the price data would be fetched
   repeated Source sources = 3;
   // rules specified on how to decide the provided price source to be accept
-  repeated RuleWithSource rules = 4;
+  repeated RuleSource rules = 4;
   // each tokenFeeder represents an active token whose price being updated
   repeated TokenFeeder token_feeders = 5;
 }
diff --git a/proto/exocore/oracle/token_feeder.proto b/proto/exocore/oracle/token_feeder.proto
index 48a0d593c..c62206e28 100644
--- a/proto/exocore/oracle/token_feeder.proto
+++ b/proto/exocore/oracle/token_feeder.proto
@@ -16,7 +16,7 @@ message NOMSource{
 //specify data from which source is needed
 //rule_1: specified sources
 //rule_2: n out of total sources are required
-message RuleWithSource{
+message RuleSource{
   //refer to params.sourceList.ID, when length>0, ignore the other field, when 1st set to 0, means all valid sources, 
   // length==0->check next field:minimum
   repeated uint64 source_ids = 1 [(gogoproto.customname) = "SourceIDs"];  
diff --git a/x/oracle/keeper/aggregator/info_test.go b/x/oracle/keeper/aggregator/info_test.go
index fe1897e10..72b0e647d 100644
--- a/x/oracle/keeper/aggregator/info_test.go
+++ b/x/oracle/keeper/aggregator/info_test.go
@@ -50,6 +50,6 @@ var defaultParams = types.Params{
 	Chains:       []*types.Chain{{Name: "-", Desc: "-"}, {Name: "Ethereum", Desc: "-"}},
 	Tokens:       []*types.Token{{}, {Name: "eth", ChainID: 1, ContractAddress: "0xabc", Decimal: 18, Active: true}},
 	Sources:      []*types.Source{{}, {Name: "chainLink", Entry: &types.Endpoint{}, Valid: true, Deterministic: true}},
-	Rules:        []*types.RuleWithSource{{}, {SourceIDs: []uint64{1}}},
+	Rules:        []*types.RuleSource{{}, {SourceIDs: []uint64{1}}},
 	TokenFeeders: []*types.TokenFeeder{{}, {TokenID: 1, RuleID: 1, StartRoundID: 1, StartBaseBlock: 0, Interval: 10, EndBlock: 0}},
 }
diff --git a/x/oracle/keeper/cache/info_test.go b/x/oracle/keeper/cache/info_test.go
index 3f5289f24..8514b8a68 100644
--- a/x/oracle/keeper/cache/info_test.go
+++ b/x/oracle/keeper/cache/info_test.go
@@ -6,6 +6,6 @@ var defaultParams = types.Params{
 	Chains:       []*types.Chain{{Name: "-", Desc: "-"}, {Name: "Ethereum", Desc: "-"}},
 	Tokens:       []*types.Token{{}, {Name: "eth", ChainID: 1, ContractAddress: "0xabc", Decimal: 18, Active: true}},
 	Sources:      []*types.Source{{}, {Name: "chainLink", Entry: &types.Endpoint{}, Valid: true, Deterministic: true}},
-	Rules:        []*types.RuleWithSource{{}, {SourceIDs: []uint64{1}}},
+	Rules:        []*types.RuleSource{{}, {SourceIDs: []uint64{1}}},
 	TokenFeeders: []*types.TokenFeeder{{}, {TokenID: 1, RuleID: 1, StartRoundID: 1, StartBaseBlock: 0, Interval: 10, EndBlock: 0}},
 }
diff --git a/x/oracle/keeper/testdata/info.go b/x/oracle/keeper/testdata/info.go
index 6b0b71f2b..e4b72872e 100644
--- a/x/oracle/keeper/testdata/info.go
+++ b/x/oracle/keeper/testdata/info.go
@@ -59,6 +59,6 @@ var DefaultParams = types.Params{
 	Chains:       []*types.Chain{{Name: "-", Desc: "-"}, {Name: "Ethereum", Desc: "-"}},
 	Tokens:       []*types.Token{{}, {Name: "eth", ChainID: 1, ContractAddress: "0xabc", Decimal: 18, Active: true}},
 	Sources:      []*types.Source{{}, {Name: "chainLink", Entry: &types.Endpoint{}, Valid: true, Deterministic: true}},
-	Rules:        []*types.RuleWithSource{{}, {SourceIDs: []uint64{1}}},
+	Rules:        []*types.RuleSource{{}, {SourceIDs: []uint64{1}}},
 	TokenFeeders: []*types.TokenFeeder{{}, {TokenID: 1, RuleID: 1, StartRoundID: 1, StartBaseBlock: 0, Interval: 10, EndBlock: 0}},
 }
diff --git a/x/oracle/types/params.go b/x/oracle/types/params.go
index 21570eb1c..038a3e26a 100644
--- a/x/oracle/types/params.go
+++ b/x/oracle/types/params.go
@@ -62,7 +62,7 @@ func DefaultParams() Params {
 				Deterministic: true,
 			},
 		},
-		Rules: []*RuleWithSource{
+		Rules: []*RuleSource{
 			// 0 is reserved
 			{},
 			{
diff --git a/x/oracle/types/params.pb.go b/x/oracle/types/params.pb.go
index 4459ee2de..ab6cad371 100644
--- a/x/oracle/types/params.pb.go
+++ b/x/oracle/types/params.pb.go
@@ -32,7 +32,7 @@ type Params struct {
 	// sources info from where the price data would be fetched
 	Sources []*Source `protobuf:"bytes,3,rep,name=sources,proto3" json:"sources,omitempty"`
 	// rules specified on how to decide the provided price source to be accept
-	Rules []*RuleWithSource `protobuf:"bytes,4,rep,name=rules,proto3" json:"rules,omitempty"`
+	Rules []*RuleSource `protobuf:"bytes,4,rep,name=rules,proto3" json:"rules,omitempty"`
 	// each tokenFeeder represents an active token whose price being updated
 	TokenFeeders []*TokenFeeder `protobuf:"bytes,5,rep,name=token_feeders,json=tokenFeeders,proto3" json:"token_feeders,omitempty"`
 }
@@ -90,7 +90,7 @@ func (m *Params) GetSources() []*Source {
 	return nil
 }
 
-func (m *Params) GetRules() []*RuleWithSource {
+func (m *Params) GetRules() []*RuleSource {
 	if m != nil {
 		return m.Rules
 	}
@@ -111,26 +111,26 @@ func init() {
 func init() { proto.RegisterFile("exocore/oracle/params.proto", fileDescriptor_ba212ceb89f5e6b2) }
 
 var fileDescriptor_ba212ceb89f5e6b2 = []byte{
-	// 300 bytes of a gzipped FileDescriptorProto
+	// 296 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xad, 0xc8, 0x4f,
 	0xce, 0x2f, 0x4a, 0xd5, 0xcf, 0x2f, 0x4a, 0x4c, 0xce, 0x49, 0xd5, 0x2f, 0x48, 0x2c, 0x4a, 0xcc,
 	0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x83, 0x4a, 0xea, 0x41, 0x24, 0xa5, 0x24,
 	0xd1, 0x14, 0x67, 0xe6, 0xa5, 0xe5, 0x43, 0x94, 0x4a, 0x29, 0xa2, 0x49, 0x95, 0xe4, 0x67, 0xa7,
 	0xe6, 0xc5, 0xa7, 0xa5, 0xa6, 0xa6, 0xa4, 0x16, 0x41, 0x95, 0x88, 0xa4, 0xe7, 0xa7, 0xe7, 0x83,
-	0x99, 0xfa, 0x20, 0x16, 0x44, 0x54, 0x69, 0x1a, 0x13, 0x17, 0x5b, 0x00, 0xd8, 0x52, 0x21, 0x5d,
+	0x99, 0xfa, 0x20, 0x16, 0x44, 0x54, 0x69, 0x12, 0x13, 0x17, 0x5b, 0x00, 0xd8, 0x52, 0x21, 0x5d,
 	0x2e, 0xb6, 0xe4, 0x8c, 0xc4, 0xcc, 0xbc, 0x62, 0x09, 0x46, 0x05, 0x66, 0x0d, 0x6e, 0x23, 0x51,
 	0x3d, 0x54, 0xfb, 0xf5, 0x9c, 0x41, 0xb2, 0x41, 0x50, 0x45, 0x20, 0xe5, 0x60, 0x5b, 0x8a, 0x25,
 	0x98, 0xb0, 0x2b, 0x0f, 0x01, 0xc9, 0x06, 0x41, 0x15, 0x09, 0x19, 0x70, 0xb1, 0x17, 0xe7, 0x97,
 	0x16, 0x25, 0xa7, 0x16, 0x4b, 0x30, 0x83, 0xd5, 0x8b, 0xa1, 0xab, 0x0f, 0x06, 0x4b, 0x07, 0xc1,
-	0x94, 0x09, 0x99, 0x70, 0xb1, 0x16, 0x95, 0xe6, 0xa4, 0x16, 0x4b, 0xb0, 0x80, 0xd5, 0xcb, 0xa1,
-	0xab, 0x0f, 0x2a, 0xcd, 0x49, 0x0d, 0xcf, 0x2c, 0xc9, 0x80, 0xea, 0x83, 0x28, 0x16, 0x72, 0xe0,
-	0xe2, 0x45, 0xf6, 0x7c, 0xb1, 0x04, 0x2b, 0x58, 0xb7, 0x34, 0x56, 0xd7, 0xb9, 0x81, 0xd5, 0x04,
-	0xf1, 0x94, 0x20, 0x38, 0xc5, 0x56, 0x2c, 0x33, 0x16, 0xc8, 0x33, 0x38, 0x79, 0x9d, 0x78, 0x24,
-	0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78,
-	0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x41, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e,
-	0x72, 0x7e, 0xae, 0xbe, 0x2b, 0xc4, 0x50, 0xbf, 0xd4, 0x92, 0xf2, 0xfc, 0xa2, 0x6c, 0x7d, 0x58,
-	0x2c, 0x54, 0xc0, 0xe3, 0xa1, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0xd6, 0xc6, 0x80, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0x9a, 0x16, 0xea, 0x86, 0xee, 0x01, 0x00, 0x00,
+	0x94, 0x09, 0x19, 0x70, 0xb1, 0x16, 0x95, 0xe6, 0xa4, 0x16, 0x4b, 0xb0, 0x80, 0xd5, 0x4b, 0xa1,
+	0xab, 0x0f, 0x2a, 0xcd, 0x49, 0x85, 0xea, 0x81, 0x28, 0x14, 0x72, 0xe0, 0xe2, 0x45, 0xf6, 0x78,
+	0xb1, 0x04, 0x2b, 0x58, 0xa7, 0x34, 0x56, 0x97, 0xb9, 0x81, 0xd5, 0x04, 0xf1, 0x94, 0x20, 0x38,
+	0xc5, 0x56, 0x2c, 0x33, 0x16, 0xc8, 0x33, 0x38, 0x79, 0x9d, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91,
+	0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3,
+	0xb1, 0x1c, 0x43, 0x94, 0x41, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0xbe,
+	0x2b, 0xc4, 0x50, 0xbf, 0xd4, 0x92, 0xf2, 0xfc, 0xa2, 0x6c, 0x7d, 0x58, 0x0c, 0x54, 0xc0, 0xe3,
+	0xa0, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0xce, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x77, 0xaa, 0x84, 0x42, 0xea, 0x01, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -442,7 +442,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Rules = append(m.Rules, &RuleWithSource{})
+			m.Rules = append(m.Rules, &RuleSource{})
 			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/x/oracle/types/token_feeder.pb.go b/x/oracle/types/token_feeder.pb.go
index 4559f7c2f..a0097ca97 100644
--- a/x/oracle/types/token_feeder.pb.go
+++ b/x/oracle/types/token_feeder.pb.go
@@ -81,7 +81,7 @@ func (m *NOMSource) GetMinimum() uint64 {
 // specify data from which source is needed
 // rule_1: specified sources
 // rule_2: n out of total sources are required
-type RuleWithSource struct {
+type RuleSource struct {
 	// refer to params.sourceList.ID, when length>0, ignore the other field, when 1st set to 0, means all valid sources,
 	// length==0->check next field:minimum
 	SourceIDs []uint64 `protobuf:"varint,1,rep,packed,name=source_ids,json=sourceIds,proto3" json:"source_ids,omitempty"`
@@ -89,18 +89,18 @@ type RuleWithSource struct {
 	Nom *NOMSource `protobuf:"bytes,2,opt,name=nom,proto3" json:"nom,omitempty"`
 }
 
-func (m *RuleWithSource) Reset()         { *m = RuleWithSource{} }
-func (m *RuleWithSource) String() string { return proto.CompactTextString(m) }
-func (*RuleWithSource) ProtoMessage()    {}
-func (*RuleWithSource) Descriptor() ([]byte, []int) {
+func (m *RuleSource) Reset()         { *m = RuleSource{} }
+func (m *RuleSource) String() string { return proto.CompactTextString(m) }
+func (*RuleSource) ProtoMessage()    {}
+func (*RuleSource) Descriptor() ([]byte, []int) {
 	return fileDescriptor_1cc86055064704d5, []int{1}
 }
-func (m *RuleWithSource) XXX_Unmarshal(b []byte) error {
+func (m *RuleSource) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *RuleWithSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *RuleSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_RuleWithSource.Marshal(b, m, deterministic)
+		return xxx_messageInfo_RuleSource.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -110,26 +110,26 @@ func (m *RuleWithSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
-func (m *RuleWithSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RuleWithSource.Merge(m, src)
+func (m *RuleSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RuleSource.Merge(m, src)
 }
-func (m *RuleWithSource) XXX_Size() int {
+func (m *RuleSource) XXX_Size() int {
 	return m.Size()
 }
-func (m *RuleWithSource) XXX_DiscardUnknown() {
-	xxx_messageInfo_RuleWithSource.DiscardUnknown(m)
+func (m *RuleSource) XXX_DiscardUnknown() {
+	xxx_messageInfo_RuleSource.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_RuleWithSource proto.InternalMessageInfo
+var xxx_messageInfo_RuleSource proto.InternalMessageInfo
 
-func (m *RuleWithSource) GetSourceIDs() []uint64 {
+func (m *RuleSource) GetSourceIDs() []uint64 {
 	if m != nil {
 		return m.SourceIDs
 	}
 	return nil
 }
 
-func (m *RuleWithSource) GetNom() *NOMSource {
+func (m *RuleSource) GetNom() *NOMSource {
 	if m != nil {
 		return m.Nom
 	}
@@ -233,40 +233,39 @@ func (m *TokenFeeder) GetEndBlock() uint64 {
 
 func init() {
 	proto.RegisterType((*NOMSource)(nil), "exocore.oracle.NOMSource")
-	proto.RegisterType((*RuleWithSource)(nil), "exocore.oracle.RuleWithSource")
+	proto.RegisterType((*RuleSource)(nil), "exocore.oracle.RuleSource")
 	proto.RegisterType((*TokenFeeder)(nil), "exocore.oracle.TokenFeeder")
 }
 
 func init() { proto.RegisterFile("exocore/oracle/token_feeder.proto", fileDescriptor_1cc86055064704d5) }
 
 var fileDescriptor_1cc86055064704d5 = []byte{
-	// 401 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xcf, 0xaa, 0xd3, 0x40,
-	0x14, 0xc6, 0x1b, 0x5b, 0x93, 0x9b, 0xe9, 0xb5, 0x5c, 0x06, 0x17, 0xf1, 0x0a, 0xc9, 0xb5, 0x82,
-	0x14, 0x94, 0x44, 0x14, 0x7c, 0x80, 0x10, 0x85, 0x08, 0x5e, 0x61, 0x2a, 0x08, 0x6e, 0x42, 0x92,
-	0x39, 0xf6, 0x86, 0xfc, 0x99, 0xcb, 0xcc, 0x44, 0xeb, 0x5b, 0xf8, 0x58, 0x2e, 0xbb, 0x74, 0x15,
-	0x24, 0x7d, 0x06, 0xf7, 0x32, 0x33, 0x6d, 0xc5, 0xad, 0xbb, 0x39, 0xf3, 0xfd, 0xce, 0xe1, 0x3b,
-	0x87, 0x0f, 0x3d, 0x82, 0x2d, 0x2b, 0x19, 0x87, 0x88, 0xf1, 0xbc, 0x6c, 0x20, 0x92, 0xac, 0x86,
-	0x2e, 0xfb, 0x0c, 0x40, 0x81, 0x87, 0xb7, 0x9c, 0x49, 0x86, 0x17, 0x07, 0x24, 0x34, 0xc8, 0xe5,
-	0xfd, 0x0d, 0xdb, 0x30, 0x2d, 0x45, 0xea, 0x65, 0xa8, 0xe5, 0x1a, 0xb9, 0xd7, 0xef, 0xdf, 0xad,
-	0x59, 0xcf, 0x4b, 0xc0, 0xcf, 0x10, 0x12, 0xfa, 0x95, 0x55, 0x54, 0x78, 0xd6, 0xd5, 0x74, 0x35,
-	0x8b, 0xef, 0x8d, 0x43, 0xe0, 0x1a, 0x3d, 0x4d, 0x04, 0x71, 0x0d, 0x90, 0x52, 0x81, 0x3d, 0xe4,
-	0xb4, 0x55, 0x57, 0xb5, 0x7d, 0xeb, 0xdd, 0xb9, 0xb2, 0x56, 0x33, 0x72, 0x2c, 0x97, 0x35, 0x5a,
-	0x90, 0xbe, 0x81, 0x8f, 0x95, 0xbc, 0xf9, 0xaf, 0xc9, 0x4f, 0xd1, 0xb4, 0x63, 0x66, 0xea, 0xfc,
-	0xc5, 0x83, 0xf0, 0xdf, 0x45, 0xc2, 0x93, 0x5f, 0xa2, 0xa8, 0xe5, 0x6f, 0x0b, 0xcd, 0x3f, 0xa8,
-	0xf5, 0xdf, 0xe8, 0xed, 0xf1, 0x13, 0x74, 0x66, 0xae, 0x51, 0x51, 0xcf, 0x52, 0xbe, 0xe2, 0xf9,
-	0x38, 0x04, 0x8e, 0x46, 0xd2, 0x84, 0x38, 0x5a, 0x4c, 0x29, 0x7e, 0x8c, 0x1c, 0xde, 0x37, 0xca,
-	0x90, 0xb1, 0x1f, 0xa3, 0x71, 0x08, 0x6c, 0xe5, 0x3b, 0x4d, 0x88, 0xad, 0xa4, 0x94, 0xe2, 0x57,
-	0x68, 0x21, 0x64, 0xce, 0x65, 0xc6, 0x59, 0xdf, 0x51, 0xc5, 0x4e, 0x35, 0x7b, 0x31, 0x0e, 0xc1,
-	0xf9, 0x5a, 0x29, 0x44, 0x09, 0x69, 0x42, 0xce, 0xc5, 0xdf, 0x8a, 0xe2, 0x15, 0xba, 0x30, 0x7d,
-	0x45, 0x2e, 0x20, 0x2b, 0x1a, 0x56, 0xd6, 0xde, 0x4c, 0x1f, 0xc9, 0xcc, 0x8b, 0x73, 0x01, 0xb1,
-	0xfa, 0xc5, 0x97, 0xe8, 0xac, 0xea, 0x24, 0xf0, 0x2f, 0x79, 0xe3, 0xdd, 0xd5, 0xc4, 0xa9, 0xc6,
-	0x0f, 0x91, 0x0b, 0x1d, 0x3d, 0xb4, 0xdb, 0x46, 0x84, 0x8e, 0xea, 0xc6, 0xf8, 0xed, 0x8f, 0xd1,
-	0xb7, 0x76, 0xa3, 0x6f, 0xfd, 0x1a, 0x7d, 0xeb, 0xfb, 0xde, 0x9f, 0xec, 0xf6, 0xfe, 0xe4, 0xe7,
-	0xde, 0x9f, 0x7c, 0x7a, 0xbe, 0xa9, 0xe4, 0x4d, 0x5f, 0x84, 0x25, 0x6b, 0xa3, 0xd7, 0xe6, 0x76,
-	0xd7, 0x20, 0xbf, 0x32, 0x5e, 0x47, 0xc7, 0xd8, 0x6c, 0x4f, 0xc1, 0xf9, 0x76, 0x0b, 0xa2, 0xb0,
-	0x75, 0x18, 0x5e, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x9a, 0x47, 0x3d, 0x82, 0x57, 0x02, 0x00,
-	0x00,
+	// 396 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xc1, 0x8a, 0xd4, 0x40,
+	0x10, 0x86, 0x27, 0xce, 0x98, 0x6c, 0x6a, 0xd6, 0x65, 0x69, 0x3c, 0xc4, 0x15, 0x92, 0x75, 0x04,
+	0x19, 0x50, 0x12, 0x51, 0xf0, 0x01, 0x42, 0x14, 0x22, 0xb8, 0x42, 0x8f, 0x27, 0x2f, 0x21, 0x49,
+	0x97, 0x31, 0x4c, 0x92, 0x5e, 0xba, 0x13, 0x5d, 0xdf, 0xc2, 0xc7, 0xf2, 0xb8, 0x47, 0x4f, 0x41,
+	0x32, 0xcf, 0xe0, 0x5d, 0xba, 0x7b, 0x66, 0xc4, 0xab, 0xb7, 0xae, 0xfe, 0xbf, 0x2a, 0xfe, 0x2a,
+	0x7e, 0x78, 0x84, 0x37, 0xbc, 0xe4, 0x02, 0x23, 0x2e, 0xf2, 0xb2, 0xc1, 0xa8, 0xe7, 0x5b, 0xec,
+	0xb2, 0x4f, 0x88, 0x0c, 0x45, 0x78, 0x2d, 0x78, 0xcf, 0xc9, 0xd9, 0x1e, 0x09, 0x0d, 0x72, 0x71,
+	0xbf, 0xe2, 0x15, 0xd7, 0x52, 0xa4, 0x5e, 0x86, 0x5a, 0x6d, 0xc0, 0xbd, 0x7a, 0xff, 0x6e, 0xc3,
+	0x07, 0x51, 0x22, 0x79, 0x06, 0x20, 0xf5, 0x2b, 0xab, 0x99, 0xf4, 0xac, 0xcb, 0xf9, 0x7a, 0x11,
+	0xdf, 0x9b, 0xc6, 0xc0, 0x35, 0x7a, 0x9a, 0x48, 0xea, 0x1a, 0x20, 0x65, 0x92, 0x78, 0xe0, 0xb4,
+	0x75, 0x57, 0xb7, 0x43, 0xeb, 0xdd, 0xb9, 0xb4, 0xd6, 0x0b, 0x7a, 0x28, 0x57, 0x15, 0x00, 0x1d,
+	0x1a, 0xfc, 0xaf, 0xa9, 0x4f, 0x61, 0xde, 0x71, 0x33, 0x71, 0xf9, 0xe2, 0x41, 0xf8, 0xef, 0x12,
+	0xe1, 0xd1, 0x2b, 0x55, 0xd4, 0xea, 0xb7, 0x05, 0xcb, 0x0f, 0x6a, 0xf5, 0x37, 0x7a, 0x73, 0xf2,
+	0x04, 0x4e, 0xcc, 0x25, 0x6a, 0xe6, 0x59, 0xca, 0x53, 0xbc, 0x9c, 0xc6, 0xc0, 0xd1, 0x48, 0x9a,
+	0x50, 0x47, 0x8b, 0x29, 0x23, 0x8f, 0xc1, 0x11, 0x43, 0xa3, 0x0c, 0x19, 0xeb, 0x31, 0x4c, 0x63,
+	0x60, 0x2b, 0xcf, 0x69, 0x42, 0x6d, 0x25, 0xa5, 0x8c, 0xbc, 0x82, 0x33, 0xd9, 0xe7, 0xa2, 0xcf,
+	0x04, 0x1f, 0x3a, 0xa6, 0xd8, 0xb9, 0x66, 0xcf, 0xa7, 0x31, 0x38, 0xdd, 0x28, 0x85, 0x2a, 0x21,
+	0x4d, 0xe8, 0xa9, 0xfc, 0x5b, 0x31, 0xb2, 0x86, 0x73, 0xd3, 0x57, 0xe4, 0x12, 0xb3, 0xa2, 0xe1,
+	0xe5, 0xd6, 0x5b, 0xe8, 0x03, 0x99, 0x79, 0x71, 0x2e, 0x31, 0x56, 0xbf, 0xe4, 0x02, 0x4e, 0xea,
+	0xae, 0x47, 0xf1, 0x25, 0x6f, 0xbc, 0xbb, 0x9a, 0x38, 0xd6, 0xe4, 0x21, 0xb8, 0xd8, 0xb1, 0x7d,
+	0xbb, 0x6d, 0x44, 0xec, 0x98, 0x6e, 0x8c, 0xdf, 0xfe, 0x98, 0x7c, 0xeb, 0x76, 0xf2, 0xad, 0x5f,
+	0x93, 0x6f, 0x7d, 0xdf, 0xf9, 0xb3, 0xdb, 0x9d, 0x3f, 0xfb, 0xb9, 0xf3, 0x67, 0x1f, 0x9f, 0x57,
+	0x75, 0xff, 0x79, 0x28, 0xc2, 0x92, 0xb7, 0xd1, 0x6b, 0x73, 0xbb, 0x2b, 0xec, 0xbf, 0x72, 0xb1,
+	0x8d, 0x0e, 0x91, 0xb9, 0x39, 0x86, 0xe6, 0xdb, 0x35, 0xca, 0xc2, 0xd6, 0x41, 0x78, 0xf9, 0x27,
+	0x00, 0x00, 0xff, 0xff, 0x3d, 0x32, 0x42, 0x06, 0x53, 0x02, 0x00, 0x00,
 }
 
 func (m *NOMSource) Marshal() (dAtA []byte, err error) {
@@ -315,7 +314,7 @@ func (m *NOMSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *RuleWithSource) Marshal() (dAtA []byte, err error) {
+func (m *RuleSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -325,12 +324,12 @@ func (m *RuleWithSource) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RuleWithSource) MarshalTo(dAtA []byte) (int, error) {
+func (m *RuleSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *RuleWithSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *RuleSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -451,7 +450,7 @@ func (m *NOMSource) Size() (n int) {
 	return n
 }
 
-func (m *RuleWithSource) Size() (n int) {
+func (m *RuleSource) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -649,7 +648,7 @@ func (m *NOMSource) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RuleWithSource) Unmarshal(dAtA []byte) error {
+func (m *RuleSource) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -672,10 +671,10 @@ func (m *RuleWithSource) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RuleWithSource: wiretype end group for non-group")
+			return fmt.Errorf("proto: RuleSource: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RuleWithSource: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RuleSource: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1: