From 49238bb36802c3c2962562530cf9972cbdab9ac0 Mon Sep 17 00:00:00 2001
From: Dan F <florentinodc@outlook.com>
Date: Fri, 22 Nov 2024 13:36:19 -0500
Subject: [PATCH] refactor: use LegacyDec for reward tracking and selector
 commission rates (#441)

* reporter module

* use legacy dec for tips and commision rates

* re-add max commision rate check

* chore: mv legacy_dec.go to types/legacy_dec.go

* minor refactor for clarity

* checkpoint to pull main

* use LgeacyDec for withdraws

* remove old BigUint to LegacyDec fcns

* linting

* add test

* linting

---------

Co-authored-by: akrem <akremstudy@gmail.com>
Co-authored-by: tkernell <tpkernell@gmail.com>
---
 api/layer/reporter/oracle_reporter.pulsar.go | 529 +------------------
 api/layer/reporter/params.pulsar.go          |  83 +--
 api/layer/reporter/query.pulsar.go           | 199 +++----
 api/layer/reporter/tx.pulsar.go              | 259 ++++-----
 proto/layer/reporter/oracle_reporter.proto   |  11 +-
 proto/layer/reporter/params.proto            |   4 +-
 proto/layer/reporter/query.proto             |   4 +-
 proto/layer/reporter/tx.proto                |   4 +-
 tests/integration/oracle_keeper_test.go      |  15 +-
 tests/integration/reporter_keeper_test.go    |  80 +++
 tests/setup.go                               |   2 +-
 {x/dispute/types => types}/legacy_dec.go     |   0
 x/oracle/keeper/aggregate.go                 |   3 +-
 x/oracle/keeper/rewards.go                   |  26 +-
 x/oracle/keeper/rewards_test.go              |  57 +-
 x/oracle/mocks/ReporterKeeper.go             |   6 +-
 x/oracle/types/expected_keepers.go           |   3 +-
 x/registry/types/decoding.go                 |   1 -
 x/reporter/keeper/distribution.go            |  57 +-
 x/reporter/keeper/distribution_test.go       |   8 +-
 x/reporter/keeper/indexes_test.go            |   2 +-
 x/reporter/keeper/keeper.go                  |   5 +-
 x/reporter/keeper/msg_server.go              |  15 +-
 x/reporter/keeper/msg_server_test.go         |  10 +-
 x/reporter/keeper/query.go                   |   2 +-
 x/reporter/keeper/query_test.go              |  16 +-
 x/reporter/keeper/withdraw.go                | 112 ++--
 x/reporter/types/message_create_reporter.go  |   2 +-
 x/reporter/types/msg_update_params_test.go   |   2 +-
 x/reporter/types/oracle_reporter.go          |   2 +-
 x/reporter/types/oracle_reporter.pb.go       | 221 +-------
 x/reporter/types/params.go                   |   6 +-
 x/reporter/types/params.pb.go                |  62 +--
 x/reporter/types/params_test.go              |  16 +-
 x/reporter/types/query.pb.go                 | 138 ++---
 x/reporter/types/tx.pb.go                    | 113 ++--
 36 files changed, 730 insertions(+), 1345 deletions(-)
 rename {x/dispute/types => types}/legacy_dec.go (100%)

diff --git a/api/layer/reporter/oracle_reporter.pulsar.go b/api/layer/reporter/oracle_reporter.pulsar.go
index 0690fdfe2..7e246332a 100644
--- a/api/layer/reporter/oracle_reporter.pulsar.go
+++ b/api/layer/reporter/oracle_reporter.pulsar.go
@@ -633,426 +633,6 @@ func (x *fastReflection_OracleReporter) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var (
-	md_BigUint       protoreflect.MessageDescriptor
-	fd_BigUint_value protoreflect.FieldDescriptor
-)
-
-func init() {
-	file_layer_reporter_oracle_reporter_proto_init()
-	md_BigUint = File_layer_reporter_oracle_reporter_proto.Messages().ByName("BigUint")
-	fd_BigUint_value = md_BigUint.Fields().ByName("value")
-}
-
-var _ protoreflect.Message = (*fastReflection_BigUint)(nil)
-
-type fastReflection_BigUint BigUint
-
-func (x *BigUint) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_BigUint)(x)
-}
-
-func (x *BigUint) slowProtoReflect() protoreflect.Message {
-	mi := &file_layer_reporter_oracle_reporter_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-var _fastReflection_BigUint_messageType fastReflection_BigUint_messageType
-var _ protoreflect.MessageType = fastReflection_BigUint_messageType{}
-
-type fastReflection_BigUint_messageType struct{}
-
-func (x fastReflection_BigUint_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_BigUint)(nil)
-}
-func (x fastReflection_BigUint_messageType) New() protoreflect.Message {
-	return new(fastReflection_BigUint)
-}
-func (x fastReflection_BigUint_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_BigUint
-}
-
-// Descriptor returns message descriptor, which contains only the protobuf
-// type information for the message.
-func (x *fastReflection_BigUint) Descriptor() protoreflect.MessageDescriptor {
-	return md_BigUint
-}
-
-// Type returns the message type, which encapsulates both Go and protobuf
-// type information. If the Go type information is not needed,
-// it is recommended that the message descriptor be used instead.
-func (x *fastReflection_BigUint) Type() protoreflect.MessageType {
-	return _fastReflection_BigUint_messageType
-}
-
-// New returns a newly allocated and mutable empty message.
-func (x *fastReflection_BigUint) New() protoreflect.Message {
-	return new(fastReflection_BigUint)
-}
-
-// Interface unwraps the message reflection interface and
-// returns the underlying ProtoMessage interface.
-func (x *fastReflection_BigUint) Interface() protoreflect.ProtoMessage {
-	return (*BigUint)(x)
-}
-
-// Range iterates over every populated field in an undefined order,
-// calling f for each field descriptor and value encountered.
-// Range returns immediately if f returns false.
-// While iterating, mutating operations may only be performed
-// on the current field descriptor.
-func (x *fastReflection_BigUint) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Value != "" {
-		value := protoreflect.ValueOfString(x.Value)
-		if !f(fd_BigUint_value, value) {
-			return
-		}
-	}
-}
-
-// Has reports whether a field is populated.
-//
-// Some fields have the property of nullability where it is possible to
-// distinguish between the default value of a field and whether the field
-// was explicitly populated with the default value. Singular message fields,
-// member fields of a oneof, and proto2 scalar fields are nullable. Such
-// fields are populated only if explicitly set.
-//
-// In other cases (aside from the nullable cases above),
-// a proto3 scalar field is populated if it contains a non-zero value, and
-// a repeated field is populated if it is non-empty.
-func (x *fastReflection_BigUint) Has(fd protoreflect.FieldDescriptor) bool {
-	switch fd.FullName() {
-	case "layer.reporter.BigUint.value":
-		return x.Value != ""
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", fd.FullName()))
-	}
-}
-
-// Clear clears the field such that a subsequent Has call reports false.
-//
-// Clearing an extension field clears both the extension type and value
-// associated with the given field number.
-//
-// Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_BigUint) Clear(fd protoreflect.FieldDescriptor) {
-	switch fd.FullName() {
-	case "layer.reporter.BigUint.value":
-		x.Value = ""
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", fd.FullName()))
-	}
-}
-
-// Get retrieves the value for a field.
-//
-// For unpopulated scalars, it returns the default value, where
-// the default value of a bytes scalar is guaranteed to be a copy.
-// For unpopulated composite types, it returns an empty, read-only view
-// of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_BigUint) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
-	switch descriptor.FullName() {
-	case "layer.reporter.BigUint.value":
-		value := x.Value
-		return protoreflect.ValueOfString(value)
-	default:
-		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", descriptor.FullName()))
-	}
-}
-
-// Set stores the value for a field.
-//
-// For a field belonging to a oneof, it implicitly clears any other field
-// that may be currently set within the same oneof.
-// For extension fields, it implicitly stores the provided ExtensionType.
-// When setting a composite type, it is unspecified whether the stored value
-// aliases the source's memory in any way. If the composite value is an
-// empty, read-only value, then it panics.
-//
-// Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_BigUint) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
-	switch fd.FullName() {
-	case "layer.reporter.BigUint.value":
-		x.Value = value.Interface().(string)
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", fd.FullName()))
-	}
-}
-
-// Mutable returns a mutable reference to a composite type.
-//
-// If the field is unpopulated, it may allocate a composite value.
-// For a field belonging to a oneof, it implicitly clears any other field
-// that may be currently set within the same oneof.
-// For extension fields, it implicitly stores the provided ExtensionType
-// if not already stored.
-// It panics if the field does not contain a composite type.
-//
-// Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_BigUint) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	switch fd.FullName() {
-	case "layer.reporter.BigUint.value":
-		panic(fmt.Errorf("field value of message layer.reporter.BigUint is not mutable"))
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", fd.FullName()))
-	}
-}
-
-// NewField returns a new value that is assignable to the field
-// for the given descriptor. For scalars, this returns the default value.
-// For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_BigUint) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	switch fd.FullName() {
-	case "layer.reporter.BigUint.value":
-		return protoreflect.ValueOfString("")
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: layer.reporter.BigUint"))
-		}
-		panic(fmt.Errorf("message layer.reporter.BigUint does not contain field %s", fd.FullName()))
-	}
-}
-
-// WhichOneof reports which field within the oneof is populated,
-// returning nil if none are populated.
-// It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_BigUint) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
-	switch d.FullName() {
-	default:
-		panic(fmt.Errorf("%s is not a oneof field in layer.reporter.BigUint", d.FullName()))
-	}
-	panic("unreachable")
-}
-
-// GetUnknown retrieves the entire list of unknown fields.
-// The caller may only mutate the contents of the RawFields
-// if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_BigUint) GetUnknown() protoreflect.RawFields {
-	return x.unknownFields
-}
-
-// SetUnknown stores an entire list of unknown fields.
-// The raw fields must be syntactically valid according to the wire format.
-// An implementation may panic if this is not the case.
-// Once stored, the caller must not mutate the content of the RawFields.
-// An empty RawFields may be passed to clear the fields.
-//
-// SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_BigUint) SetUnknown(fields protoreflect.RawFields) {
-	x.unknownFields = fields
-}
-
-// IsValid reports whether the message is valid.
-//
-// An invalid message is an empty, read-only value.
-//
-// An invalid message often corresponds to a nil pointer of the concrete
-// message type, but the details are implementation dependent.
-// Validity is not part of the protobuf data model, and may not
-// be preserved in marshaling or other operations.
-func (x *fastReflection_BigUint) IsValid() bool {
-	return x != nil
-}
-
-// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
-// This method may return nil.
-//
-// The returned methods type is identical to
-// "google.golang.org/protobuf/runtime/protoiface".Methods.
-// Consult the protoiface package documentation for details.
-func (x *fastReflection_BigUint) ProtoMethods() *protoiface.Methods {
-	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*BigUint)
-		if x == nil {
-			return protoiface.SizeOutput{
-				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-				Size:              0,
-			}
-		}
-		options := runtime.SizeInputToOptions(input)
-		_ = options
-		var n int
-		var l int
-		_ = l
-		l = len(x.Value)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.unknownFields != nil {
-			n += len(x.unknownFields)
-		}
-		return protoiface.SizeOutput{
-			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-			Size:              n,
-		}
-	}
-
-	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*BigUint)
-		if x == nil {
-			return protoiface.MarshalOutput{
-				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-				Buf:               input.Buf,
-			}, nil
-		}
-		options := runtime.MarshalInputToOptions(input)
-		_ = options
-		size := options.Size(x)
-		dAtA := make([]byte, size)
-		i := len(dAtA)
-		_ = i
-		var l int
-		_ = l
-		if x.unknownFields != nil {
-			i -= len(x.unknownFields)
-			copy(dAtA[i:], x.unknownFields)
-		}
-		if len(x.Value) > 0 {
-			i -= len(x.Value)
-			copy(dAtA[i:], x.Value)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Value)))
-			i--
-			dAtA[i] = 0xa
-		}
-		if input.Buf != nil {
-			input.Buf = append(input.Buf, dAtA...)
-		} else {
-			input.Buf = dAtA
-		}
-		return protoiface.MarshalOutput{
-			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-			Buf:               input.Buf,
-		}, nil
-	}
-	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*BigUint)
-		if x == nil {
-			return protoiface.UnmarshalOutput{
-				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-				Flags:             input.Flags,
-			}, nil
-		}
-		options := runtime.UnmarshalInputToOptions(input)
-		_ = options
-		dAtA := input.Buf
-		l := len(dAtA)
-		iNdEx := 0
-		for iNdEx < l {
-			preIndex := iNdEx
-			var wire uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-				}
-				if iNdEx >= l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				wire |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			fieldNum := int32(wire >> 3)
-			wireType := int(wire & 0x7)
-			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BigUint: wiretype end group for non-group")
-			}
-			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: BigUint: illegal tag %d (wire type %d)", fieldNum, wire)
-			}
-			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Value = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if (iNdEx + skippy) > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
-				}
-				iNdEx += skippy
-			}
-		}
-
-		if iNdEx > l {
-			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-		}
-		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
-	}
-	return &protoiface.Methods{
-		NoUnkeyedLiterals: struct{}{},
-		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
-		Size:              size,
-		Marshal:           marshal,
-		Unmarshal:         unmarshal,
-		Merge:             nil,
-		CheckInitialized:  nil,
-	}
-}
-
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.27.0
@@ -1130,41 +710,6 @@ func (x *OracleReporter) GetJailedUntil() *timestamppb.Timestamp {
 	return nil
 }
 
-type BigUint struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *BigUint) Reset() {
-	*x = BigUint{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_layer_reporter_oracle_reporter_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BigUint) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BigUint) ProtoMessage() {}
-
-// Deprecated: Use BigUint.ProtoReflect.Descriptor instead.
-func (*BigUint) Descriptor() ([]byte, []int) {
-	return file_layer_reporter_oracle_reporter_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *BigUint) GetValue() string {
-	if x != nil {
-		return x.Value
-	}
-	return ""
-}
-
 var File_layer_reporter_oracle_reporter_proto protoreflect.FileDescriptor
 
 var file_layer_reporter_oracle_reporter_proto_rawDesc = []byte{
@@ -1177,43 +722,38 @@ var file_layer_reporter_oracle_reporter_proto_rawDesc = []byte{
 	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
 	0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67,
 	0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xab, 0x02, 0x0a, 0x0e,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb5, 0x02, 0x0a, 0x0e,
 	0x4f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x5b,
 	0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x5f, 0x72, 0x65, 0x71,
 	0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f,
 	0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69,
 	0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f,
 	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x56, 0x0a, 0x0f, 0x63,
+	0x65, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x60, 0x0a, 0x0f, 0x63,
 	0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x42, 0x2d, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x16, 0x63, 0x6f,
+	0x20, 0x01, 0x28, 0x09, 0x42, 0x37, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f,
 	0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e,
-	0x55, 0x69, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x55,
-	0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52,
-	0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x06, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x4c, 0x0a, 0x0c, 0x6a,
-	0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8,
-	0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0b, 0x6a, 0x61,
-	0x69, 0x6c, 0x65, 0x64, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x22, 0x4e, 0x0a, 0x07, 0x42, 0x69, 0x67,
-	0x55, 0x69, 0x6e, 0x74, 0x12, 0x43, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x42, 0x2d, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x16, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x55,
-	0x69, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x55, 0x69,
-	0x6e, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0xb1, 0x01, 0x0a, 0x12, 0x63, 0x6f,
-	0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x42, 0x13, 0x4f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61,
-	0x79, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e, 0x4c,
-	0x61, 0x79, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02, 0x0e,
-	0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2, 0x02,
-	0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5c,
-	0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c, 0x61,
-	0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x10, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0x52, 0x0e, 0x63,
+	0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a,
+	0x06, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x6a,
+	0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x4c, 0x0a, 0x0c, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f,
+	0x75, 0x6e, 0x74, 0x69, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f,
+	0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0b, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x6e,
+	0x74, 0x69, 0x6c, 0x42, 0xb1, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65,
+	0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x42, 0x13, 0x4f, 0x72, 0x61, 0x63,
+	0x6c, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
+	0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65,
+	0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x52,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c,
+	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72,
+	0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1228,14 +768,13 @@ func file_layer_reporter_oracle_reporter_proto_rawDescGZIP() []byte {
 	return file_layer_reporter_oracle_reporter_proto_rawDescData
 }
 
-var file_layer_reporter_oracle_reporter_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_layer_reporter_oracle_reporter_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
 var file_layer_reporter_oracle_reporter_proto_goTypes = []interface{}{
 	(*OracleReporter)(nil),        // 0: layer.reporter.OracleReporter
-	(*BigUint)(nil),               // 1: layer.reporter.BigUint
-	(*timestamppb.Timestamp)(nil), // 2: google.protobuf.Timestamp
+	(*timestamppb.Timestamp)(nil), // 1: google.protobuf.Timestamp
 }
 var file_layer_reporter_oracle_reporter_proto_depIdxs = []int32{
-	2, // 0: layer.reporter.OracleReporter.jailed_until:type_name -> google.protobuf.Timestamp
+	1, // 0: layer.reporter.OracleReporter.jailed_until:type_name -> google.protobuf.Timestamp
 	1, // [1:1] is the sub-list for method output_type
 	1, // [1:1] is the sub-list for method input_type
 	1, // [1:1] is the sub-list for extension type_name
@@ -1261,18 +800,6 @@ func file_layer_reporter_oracle_reporter_proto_init() {
 				return nil
 			}
 		}
-		file_layer_reporter_oracle_reporter_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BigUint); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -1280,7 +807,7 @@ func file_layer_reporter_oracle_reporter_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_layer_reporter_oracle_reporter_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   2,
+			NumMessages:   1,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/api/layer/reporter/params.pulsar.go b/api/layer/reporter/params.pulsar.go
index 70a6f208c..cf040b323 100644
--- a/api/layer/reporter/params.pulsar.go
+++ b/api/layer/reporter/params.pulsar.go
@@ -1170,47 +1170,48 @@ var file_layer_reporter_params_proto_rawDesc = []byte{
 	0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
 	0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
 	0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x22, 0xa4, 0x02, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x7b, 0x0a,
-	0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
-	0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x4b, 0xc8, 0xde, 0x1f, 0x00,
-	0xda, 0xde, 0x1f, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f,
-	0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0xf2, 0xde, 0x1f, 0x1a, 0x79, 0x61,
-	0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69,
-	0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x22, 0xd2, 0xb4, 0x2d, 0x0b, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6d, 0x6d,
-	0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x56, 0x0a, 0x07, 0x6d, 0x69,
-	0x6e, 0x5f, 0x74, 0x72, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3d, 0xc8, 0xde, 0x1f,
-	0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69,
-	0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xf2, 0xde, 0x1f, 0x0e, 0x79, 0x61,
-	0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x72, 0x62, 0x22, 0xd2, 0xb4, 0x2d, 0x0a,
-	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x54,
-	0x72, 0x62, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x53, 0x65,
-	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x3a, 0x20, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0,
-	0x2a, 0x17, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x78, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0xa6, 0x01, 0x0a, 0x0c, 0x53, 0x74,
-	0x61, 0x6b, 0x65, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x0a, 0x65, 0x78,
-	0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x04, 0x90, 0xdf, 0x1f, 0x01,
-	0x52, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x54, 0x0a, 0x06,
-	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3c, 0xc8, 0xde,
-	0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e,
-	0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xf2, 0xde, 0x1f, 0x0d, 0x79,
-	0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xd2, 0xb4, 0x2d, 0x0a,
-	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75,
-	0x6e, 0x74, 0x42, 0xa9, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72,
-	0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d,
-	0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c,
-	0x61, 0x79, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72,
-	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e,
-	0x4c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02,
-	0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2,
-	0x02, 0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c,
-	0x61, 0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x74, 0x6f, 0x22, 0xaf, 0x02, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x85, 0x01,
+	0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e,
+	0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x55, 0xc8, 0xde, 0x1f,
+	0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69,
+	0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63,
+	0xf2, 0xde, 0x1f, 0x1a, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f,
+	0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x22, 0xd2, 0xb4,
+	0x2d, 0x10, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44,
+	0x65, 0x63, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f,
+	0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x56, 0x0a, 0x07, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x72, 0x62,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3d, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74,
+	0x68, 0x2e, 0x49, 0x6e, 0x74, 0xf2, 0xde, 0x1f, 0x0e, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d,
+	0x69, 0x6e, 0x5f, 0x74, 0x72, 0x62, 0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x54, 0x72, 0x62, 0x12, 0x23, 0x0a,
+	0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f,
+	0x72, 0x73, 0x3a, 0x20, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x17, 0x6c, 0x61, 0x79,
+	0x65, 0x72, 0x2f, 0x78, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x22, 0xa6, 0x01, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x54, 0x72,
+	0x61, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x04, 0x90, 0xdf, 0x1f, 0x01, 0x52, 0x0a, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x54, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3c, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f,
+	0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61,
+	0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xf2, 0xde, 0x1f, 0x0d, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22,
+	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0xa9, 0x01,
+	0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f,
+	0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72,
+	0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65,
+	0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61, 0x79,
+	0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x3a,
+	0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
 }
 
 var (
diff --git a/api/layer/reporter/query.pulsar.go b/api/layer/reporter/query.pulsar.go
index 46a61c237..14f935435 100644
--- a/api/layer/reporter/query.pulsar.go
+++ b/api/layer/reporter/query.pulsar.go
@@ -7994,114 +7994,115 @@ var file_layer_reporter_query_proto_rawDesc = []byte{
 	0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
 	0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52,
 	0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x22, 0x72, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
-	0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x54,
+	0x22, 0x7c, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
+	0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e,
 	0x0a, 0x0e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x74, 0x69, 0x70, 0x73,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2d, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x16,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x37, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b,
 	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74,
-	0x68, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
-	0x2e, 0x55, 0x69, 0x6e, 0x74, 0x52, 0x0d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65,
-	0x54, 0x69, 0x70, 0x73, 0x32, 0x8e, 0x0b, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x7b,
-	0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x22, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72,
-	0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
-	0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6c,
-	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x74, 0x65, 0x6c, 0x6c,
-	0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x87, 0x01, 0x0a, 0x09,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73, 0x12, 0x25, 0x2e, 0x6c, 0x61, 0x79, 0x65,
-	0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x26, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
-	0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25,
-	0x12, 0x23, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79,
-	0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x65, 0x72, 0x73, 0x12, 0xb7, 0x01, 0x0a, 0x10, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x6c, 0x61, 0x79,
+	0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x10, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0x52,
+	0x0d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x32, 0x8e,
+	0x0b, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x7b, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x12, 0x22, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72,
+	0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f,
+	0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x70,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x87, 0x01, 0x0a, 0x09, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x73, 0x12, 0x25, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6c, 0x61, 0x79,
 	0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
-	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72,
-	0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53,
-	0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12,
-	0x3e, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65,
-	0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x73, 0x65, 0x6c, 0x65, 0x63,
-	0x74, 0x6f, 0x72, 0x2d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x7b, 0x73, 0x65,
-	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12,
-	0x98, 0x01, 0x0a, 0x0d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e,
-	0x74, 0x12, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6c,
-	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a,
-	0x12, 0x28, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79,
-	0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x61, 0x6c, 0x6c, 0x6f,
-	0x77, 0x65, 0x64, 0x2d, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0xc1, 0x01, 0x0a, 0x17, 0x41,
-	0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x70, 0x69,
-	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72,
-	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x6c, 0x61,
-	0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45,
-	0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x3b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x74, 0x65, 0x6c, 0x6c,
+	0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x12, 0x23, 0x2f, 0x74, 0x65, 0x6c,
+	0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x73, 0x12,
+	0xb7, 0x01, 0x0a, 0x10, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63,
+	0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f,
+	0x72, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x74, 0x65, 0x6c, 0x6c,
 	0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x65, 0x72, 0x2f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x2d, 0x61, 0x6d, 0x6f,
-	0x75, 0x6e, 0x74, 0x2d, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0xda,
-	0x01, 0x0a, 0x18, 0x4e, 0x75, 0x6d, 0x4f, 0x66, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
-	0x73, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6c, 0x61,
+	0x72, 0x74, 0x65, 0x72, 0x2f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2d, 0x72, 0x65,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x7b, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0x98, 0x01, 0x0a, 0x0d, 0x41, 0x6c,
+	0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x29, 0x2e, 0x6c, 0x61,
+	0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
+	0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, 0x2f, 0x74, 0x65, 0x6c,
+	0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x2d, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x12, 0xc1, 0x01, 0x0a, 0x17, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64,
+	0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x33, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
+	0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x41, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x6f,
+	0x77, 0x65, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3b, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f,
+	0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x61,
+	0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x2d, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x2d, 0x65, 0x78,
+	0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0xda, 0x01, 0x0a, 0x18, 0x4e, 0x75, 0x6d,
+	0x4f, 0x66, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x42, 0x79, 0x52, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x75, 0x6d, 0x4f,
+	0x66, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6c, 0x61,
 	0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65,
 	0x72, 0x79, 0x4e, 0x75, 0x6d, 0x4f, 0x66, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73,
-	0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x35, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x75, 0x6d, 0x4f, 0x66, 0x53, 0x65, 0x6c,
-	0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x51, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b,
-	0x12, 0x49, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79,
-	0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x6e, 0x75, 0x6d, 0x2d,
-	0x6f, 0x66, 0x2d, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x2d, 0x62, 0x79, 0x2d,
-	0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x18,
-	0x53, 0x70, 0x61, 0x63, 0x65, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72,
+	0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x51, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b, 0x12, 0x49, 0x2f, 0x74, 0x65, 0x6c,
+	0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x6e, 0x75, 0x6d, 0x2d, 0x6f, 0x66, 0x2d, 0x73, 0x65, 0x6c,
+	0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x2d, 0x62, 0x79, 0x2d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x18, 0x53, 0x70, 0x61, 0x63, 0x65, 0x41,
+	0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x12, 0x34, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x61, 0x63, 0x65, 0x41, 0x76,
+	0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
+	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72,
 	0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53,
 	0x70, 0x61, 0x63, 0x65, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79, 0x52,
-	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x50, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4a, 0x12, 0x48, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72,
+	0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x2f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
+	0x6c, 0x65, 0x2d, 0x62, 0x79, 0x2d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x7b,
+	0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x7d, 0x12, 0xab, 0x01, 0x0a, 0x0d, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54,
+	0x69, 0x70, 0x73, 0x12, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61,
+	0x62, 0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a,
 	0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x61, 0x63, 0x65, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61,
-	0x62, 0x6c, 0x65, 0x42, 0x79, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4a, 0x12, 0x48, 0x2f,
-	0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f,
-	0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2d, 0x61,
-	0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x62, 0x79, 0x2d, 0x72, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x65, 0x72, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xab, 0x01, 0x0a, 0x0d, 0x41, 0x76, 0x61, 0x69,
-	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x12, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65,
-	0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x76, 0x61, 0x69, 0x6c,
-	0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x43, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3d, 0x12, 0x3b, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f,
-	0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x74, 0x69,
-	0x70, 0x73, 0x2f, 0x7b, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x7d, 0x42, 0xa8, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61,
-	0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68,
-	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f,
-	0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72,
-	0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa,
-	0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
-	0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
-	0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69,
+	0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x3d, 0x12, 0x3b, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x61, 0x76,
+	0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x74, 0x69, 0x70, 0x73, 0x2f, 0x7b, 0x73, 0x65,
+	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x42,
+	0xa8, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
+	0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72,
+	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65,
+	0x72, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79,
+	0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61,
+	0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72,
+	0x3a, 0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 }
 
 var (
diff --git a/api/layer/reporter/tx.pulsar.go b/api/layer/reporter/tx.pulsar.go
index 08c1cca57..212d7a9aa 100644
--- a/api/layer/reporter/tx.pulsar.go
+++ b/api/layer/reporter/tx.pulsar.go
@@ -6465,140 +6465,141 @@ var file_layer_reporter_tx_proto_rawDesc = []byte{
 	0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
 	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55,
 	0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x8f, 0x02, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x6e, 0x73, 0x65, 0x22, 0x99, 0x02, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
 	0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70,
 	0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
 	0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x5b, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69,
-	0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x32, 0xc8,
-	0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
-	0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0xd2, 0xb4, 0x2d,
-	0x0b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a,
-	0x01, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74,
-	0x65, 0x12, 0x5b, 0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x5f,
-	0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b,
-	0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64,
-	0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d,
-	0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x3a, 0x15,
-	0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0xb4, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65,
-	0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65,
-	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x43, 0x0a,
-	0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
-	0x67, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x3a, 0x15, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f,
-	0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67,
-	0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb4, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x53, 0x77,
-	0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x10,
-	0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
-	0x52, 0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x12, 0x43, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d,
-	0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x15, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x73, 0x65, 0x6c,
-	0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a,
-	0x19, 0x4d, 0x73, 0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa5, 0x01, 0x0a, 0x11, 0x4d,
-	0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
-	0x12, 0x39, 0x0a, 0x0b, 0x61, 0x6e, 0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
-	0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52,
-	0x0a, 0x61, 0x6e, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x73,
-	0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
+	0x72, 0x65, 0x73, 0x73, 0x12, 0x65, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69,
+	0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3c, 0xc8,
+	0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44,
+	0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x10, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4c, 0x65, 0x67,
+	0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0e, 0x63, 0x6f, 0x6d,
+	0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x5b, 0x0a, 0x13, 0x6d,
+	0x69, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde,
+	0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d,
+	0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x3a, 0x15, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x72,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22,
+	0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f,
+	0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb4, 0x01, 0x0a,
+	0x11, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4,
+	0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72,
+	0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x72, 0x65, 0x70,
+	0x6f, 0x72, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x15, 0x82, 0xe7,
+	0xb0, 0x2a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
+	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0xb4, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65,
+	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x65,
+	0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x72,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
 	0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
 	0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52,
-	0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x3a, 0x10, 0x82, 0xe7, 0xb0, 0x2a, 0x0b, 0x61, 0x6e, 0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53,
-	0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x77, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18,
-	0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x1d, 0x88, 0xa0, 0x1f, 0x00, 0xe8,
-	0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x55,
-	0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xbc, 0x01, 0x0a, 0x0e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74,
-	0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65,
-	0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65,
-	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a,
-	0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f,
-	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x15, 0x82,
-	0xe7, 0xb0, 0x2a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64,
-	0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x9d,
-	0x05, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x58, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
-	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1f, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72,
-	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74,
-	0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x27, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e,
-	0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
-	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5e, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5e, 0x0a, 0x0e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5e, 0x0a, 0x0e, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5e, 0x0a, 0x0e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x12, 0x21, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c,
-	0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65,
-	0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5e, 0x0a, 0x0e, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
-	0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x55, 0x0a, 0x0b, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x12,
-	0x1e, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x1a,
-	0x26, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
-	0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xa5,
-	0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70,
-	0x6f, 0x72, 0x74, 0x65, 0x72, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
-	0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65, 0x6c,
-	0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69,
-	0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xa2,
-	0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x52, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52,
-	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c,
-	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52, 0x65,
-	0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x3a, 0x15, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x77,
+	0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa5, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f,
+	0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x39, 0x0a, 0x0b, 0x61, 0x6e,
+	0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0a, 0x61, 0x6e, 0x79, 0x41, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f,
+	0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x10, 0x82, 0xe7, 0xb0, 0x2a,
+	0x0b, 0x61, 0x6e, 0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19,
+	0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f,
+	0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x77, 0x0a, 0x11, 0x4d, 0x73, 0x67,
+	0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x43,
+	0x0a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x3a, 0x1d, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0,
+	0x2a, 0x10, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52,
+	0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0xbc, 0x01, 0x0a, 0x0e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54,
+	0x69, 0x70, 0x12, 0x43, 0x0a, 0x10, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4,
+	0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x15, 0x82, 0xe7, 0xb0, 0x2a, 0x10, 0x73, 0x65,
+	0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x18,
+	0x0a, 0x16, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x9d, 0x05, 0x0a, 0x03, 0x4d, 0x73, 0x67,
+	0x12, 0x58, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x1f, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
+	0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x73, 0x1a, 0x27, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0e, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+	0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a,
+	0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0e, 0x53, 0x65,
+	0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+	0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a,
+	0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0e, 0x53, 0x77,
+	0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+	0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a,
+	0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x2e, 0x4d, 0x73, 0x67, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0e, 0x52, 0x65,
+	0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x2e, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+	0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a,
+	0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74,
+	0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0e, 0x55, 0x6e,
+	0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x6c,
+	0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73,
+	0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x1a,
+	0x29, 0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x55, 0x0a, 0x0b, 0x57, 0x69,
+	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x12, 0x1e, 0x2e, 0x6c, 0x61, 0x79, 0x65,
+	0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69,
+	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x1a, 0x26, 0x2e, 0x6c, 0x61, 0x79, 0x65,
+	0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69,
+	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x54, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xa5, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d,
+	0x2e, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x42,
+	0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x72, 0x2d, 0x69, 0x6f,
+	0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x79, 0x65, 0x72,
+	0x2f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x4c, 0x52, 0x58, 0xaa,
+	0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0xca, 0x02, 0x0e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65,
+	0x72, 0xe2, 0x02, 0x1a, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x5c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
+	0x0f, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x3a, 0x3a, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/proto/layer/reporter/oracle_reporter.proto b/proto/layer/reporter/oracle_reporter.proto
index a9e59f30b..7919700e8 100644
--- a/proto/layer/reporter/oracle_reporter.proto
+++ b/proto/layer/reporter/oracle_reporter.proto
@@ -18,8 +18,8 @@ message OracleReporter {
   ];
   // commission for the reporter
   string commission_rate = 2 [
-    (cosmos_proto.scalar) = "cosmos.Uint",
-    (gogoproto.customtype) = "cosmossdk.io/math.Uint",
+    (cosmos_proto.scalar) = "cosmos.LegacyDec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false
   ];
   // jailed is a bool whether the reporter is jailed or not
@@ -32,10 +32,3 @@ message OracleReporter {
   ];
 }
 
-message BigUint {
-  string value = 1 [
-    (cosmos_proto.scalar) = "cosmos.Uint",
-    (gogoproto.customtype) = "cosmossdk.io/math.Uint",
-    (gogoproto.nullable) = false
-  ];
-}
diff --git a/proto/layer/reporter/params.proto b/proto/layer/reporter/params.proto
index 932ce5809..37ba2d9a7 100644
--- a/proto/layer/reporter/params.proto
+++ b/proto/layer/reporter/params.proto
@@ -16,9 +16,9 @@ message Params {
   // min_commission_rate, adopted from staking module, is the minimum commission rate a reporter can their delegators
   string min_commission_rate = 1 [
     (gogoproto.moretags) = "yaml:\"min_commission_rate\"",
-    (gogoproto.customtype) = "cosmossdk.io/math.Uint",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false,
-    (cosmos_proto.scalar) = "cosmos.Uint"
+    (cosmos_proto.scalar) = "cosmos.LegacyDec"
   ];
   // min_trb to be a reporter
   string min_trb = 2 [
diff --git a/proto/layer/reporter/query.proto b/proto/layer/reporter/query.proto
index 6797eaa07..5e0b9090d 100644
--- a/proto/layer/reporter/query.proto
+++ b/proto/layer/reporter/query.proto
@@ -160,8 +160,8 @@ message QueryAvailableTipsRequest {
 message QueryAvailableTipsResponse {
   // available_tips defines the tips available for withdrawal for a given selector.
   string available_tips = 1 [
-    (cosmos_proto.scalar) = "cosmos.Uint",
-    (gogoproto.customtype) = "cosmossdk.io/math.Uint",
+    (cosmos_proto.scalar) = "cosmos.LegacyDec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false
   ];
 }
diff --git a/proto/layer/reporter/tx.proto b/proto/layer/reporter/tx.proto
index 23c505b31..7f3866c8e 100644
--- a/proto/layer/reporter/tx.proto
+++ b/proto/layer/reporter/tx.proto
@@ -68,8 +68,8 @@ message MsgCreateReporter {
   // reporter_address is the address of the reporter.
   string reporter_address = 1;
   string commission_rate = 2 [
-    (cosmos_proto.scalar) = "cosmos.Uint",
-    (gogoproto.customtype) = "cosmossdk.io/math.Uint",
+    (cosmos_proto.scalar) = "cosmos.LegacyDec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false,
     (amino.dont_omitempty) = true
   ];
diff --git a/tests/integration/oracle_keeper_test.go b/tests/integration/oracle_keeper_test.go
index ab9391ebb..195acc2d7 100644
--- a/tests/integration/oracle_keeper_test.go
+++ b/tests/integration/oracle_keeper_test.go
@@ -338,9 +338,11 @@ func (s *IntegrationTestSuite) TestTimeBasedRewardsOneReporter() {
 	repAccs, valAddrs, _ := s.createValidatorAccs([]uint64{reporterPower})
 	s.NoError(s.Setup.Reporterkeeper.Reporters.Set(s.Setup.Ctx, repAccs[0], reportertypes.NewReporter(reportertypes.DefaultMinCommissionRate, math.OneInt())))
 	s.NoError(s.Setup.Reporterkeeper.Selectors.Set(s.Setup.Ctx, repAccs[0], reportertypes.NewSelection(repAccs[0], 1)))
+
 	qId := utils.QueryIDFromData(ethQueryData)
 	stake, err := s.Setup.Reporterkeeper.ReporterStake(s.Setup.Ctx, repAccs[0], qId)
 	s.NoError(err)
+
 	// send timebasedrewards tokens to oracle module to pay reporters with
 	tipper := s.newKeysWithTokens()
 	reward := math.NewInt(100)
@@ -349,7 +351,6 @@ func (s *IntegrationTestSuite) TestTimeBasedRewardsOneReporter() {
 
 	// testing for a query id and check if the reporter gets the reward, bypassing the commit/reveal process
 	value := []string{"000001"}
-
 	reports := testutil.GenerateReports([]sdk.AccAddress{repAccs[0]}, value, []uint64{reporterPower}, qId)
 
 	aggregateReport, err := s.Setup.Oraclekeeper.WeightedMedian(s.Setup.Ctx, reports[:1], 1)
@@ -371,7 +372,7 @@ func (s *IntegrationTestSuite) TestTimeBasedRewardsOneReporter() {
 
 	tip, err := s.Setup.Reporterkeeper.SelectorTips.Get(s.Setup.Ctx, repAccs[0].Bytes())
 	s.NoError(err)
-	s.Equal(tip.Value, math.NewUint(reward.Uint64()*1e6), "reporter should get the reward")
+	s.Equal(tip.TruncateInt(), reward, "reporter should get the reward")
 	// withdraw the reward
 	repServer := reporterkeeper.NewMsgServerImpl(s.Setup.Reporterkeeper)
 	_, err = repServer.WithdrawTip(s.Setup.Ctx, &reportertypes.MsgWithdrawTip{SelectorAddress: repAccs[0].String(), ValidatorAddress: valAddrs[0].String()})
@@ -416,14 +417,14 @@ func (s *IntegrationTestSuite) TestTimeBasedRewardsTwoReporters() {
 			name:                 "reporter with 1 voting power",
 			reporterIndex:        0,
 			beforeBalance:        reporterStake,
-			afterBalanceIncrease: math.Int(keeper.CalculateRewardAmount(reporterPower1, 1, totalReporterPower, reward).Value.QuoUint64(1e6)),
+			afterBalanceIncrease: keeper.CalculateRewardAmount(reporterPower1, 1, totalReporterPower, reward).TruncateInt(),
 			delegator:            repAccs[0],
 		},
 		{
 			name:                 "reporter with 2 voting power",
 			reporterIndex:        1,
 			beforeBalance:        reporterStake2,
-			afterBalanceIncrease: math.Int(keeper.CalculateRewardAmount(reporterPower2, 1, totalReporterPower, reward).Value.QuoUint64(1e6)),
+			afterBalanceIncrease: keeper.CalculateRewardAmount(reporterPower2, 1, totalReporterPower, reward).TruncateInt(),
 			delegator:            repAccs[1],
 		},
 	}
@@ -492,21 +493,21 @@ func (s *IntegrationTestSuite) TestTimeBasedRewardsThreeReporters() {
 			name:                 "reporter with 100 voting power",
 			reporterIndex:        0,
 			beforeBalance:        reporterStake,
-			afterBalanceIncrease: math.Int(keeper.CalculateRewardAmount(reporterPower1, 1, totalPower, reward).Value.QuoUint64(1e6)),
+			afterBalanceIncrease: keeper.CalculateRewardAmount(reporterPower1, 1, totalPower, reward).TruncateInt(),
 			delegator:            repAccs[0],
 		},
 		{
 			name:                 "reporter with 200 voting power",
 			reporterIndex:        1,
 			beforeBalance:        reporterStake2,
-			afterBalanceIncrease: math.Int(keeper.CalculateRewardAmount(reporterPower2, 1, totalPower, reward).Value.QuoUint64(1e6)),
+			afterBalanceIncrease: keeper.CalculateRewardAmount(reporterPower2, 1, totalPower, reward).TruncateInt(),
 			delegator:            repAccs[1],
 		},
 		{
 			name:                 "reporter with 300 voting power",
 			reporterIndex:        2,
 			beforeBalance:        reporterStake3,
-			afterBalanceIncrease: math.Int(keeper.CalculateRewardAmount(reporterPower3, 1, totalPower, reward).Value.QuoUint64(1e6)),
+			afterBalanceIncrease: keeper.CalculateRewardAmount(reporterPower3, 1, totalPower, reward).TruncateInt(),
 			delegator:            repAccs[2],
 		},
 	}
diff --git a/tests/integration/reporter_keeper_test.go b/tests/integration/reporter_keeper_test.go
index c9d1236b7..e324fb75c 100644
--- a/tests/integration/reporter_keeper_test.go
+++ b/tests/integration/reporter_keeper_test.go
@@ -6,6 +6,7 @@ import (
 
 	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
 	"github.com/tellor-io/layer/testutil/sample"
+	layertypes "github.com/tellor-io/layer/types"
 	"github.com/tellor-io/layer/x/reporter/keeper"
 	reportertypes "github.com/tellor-io/layer/x/reporter/types"
 
@@ -392,3 +393,82 @@ func (s *IntegrationTestSuite) TestEscrowReporterStake() {
 	_, err = sk.Slash(ctx, sdk.ConsAddress(cmtPk.Address()).Bytes(), blockHeightAtFullPower, valPower, math.LegacyNewDecWithPrec(5, 1))
 	s.NoError(err)
 }
+
+func (s *IntegrationTestSuite) TestEscrowReporterStake2() {
+	ctx := s.Setup.Ctx
+	rk := s.Setup.Reporterkeeper
+	ctx = ctx.WithBlockTime(time.Now())
+	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
+	height := uint64(ctx.BlockHeight())
+	s.Equal(height, uint64(1))
+
+	delAddr, valAddrs, _ := s.createValidatorAccs([]uint64{100, 200, 300, 400, 500})
+	for _, val := range valAddrs {
+		err := s.Setup.Bridgekeeper.SetEVMAddressByOperator(ctx, val.String(), []byte("not real"))
+		s.NoError(err)
+	}
+	reporter := delAddr[0]
+	delAddr = delAddr[1:]
+
+	err := rk.Reporters.Set(ctx, reporter, reportertypes.OracleReporter{
+		MinTokensRequired: reportertypes.DefaultMinTrb,
+		CommissionRate:    reportertypes.DefaultMinCommissionRate,
+	})
+	s.NoError(err)
+
+	for _, selector := range delAddr {
+		err = rk.Selectors.Set(ctx, selector, reportertypes.Selection{
+			Reporter:         reporter,
+			DelegationsCount: 1,
+		})
+		s.NoError(err)
+	}
+
+	reporterStake, err := rk.ReporterStake(ctx, reporter, []byte("queryid1"))
+	s.NoError(err)
+	s.Equal(math.NewInt(2_800_000_000), reporterStake)
+	// -------------------------------------------------
+	err = rk.EscrowReporterStake(ctx, reporter, math.NewInt(2_800_000_000).Quo(layertypes.PowerReduction).Uint64(), height, math.NewInt(800), []byte("queryid1"), []byte("hashId"))
+	s.NoError(err)
+
+	reporterStake, err = rk.ReporterStake(ctx, reporter, []byte("queryid2"))
+	s.NoError(err)
+	stakeleft := 2_800_000_000 - 800
+	s.Equal(math.NewInt(int64(stakeleft)), reporterStake)
+	// -------------------------------------------------
+	err = rk.EscrowReporterStake(ctx, reporter, reporterStake.Quo(layertypes.PowerReduction).Uint64(), height, math.NewInt(8000), []byte("queryid2"), []byte("hashId2"))
+	s.NoError(err)
+
+	reporterStake, err = rk.ReporterStake(ctx, reporter, []byte("queryid3"))
+	s.NoError(err)
+	stakeleft -= 8000
+	s.Equal(math.NewInt(int64(stakeleft)), reporterStake)
+	// -------------------------------------------------
+	err = rk.EscrowReporterStake(ctx, reporter, reporterStake.Quo(layertypes.PowerReduction).Uint64(), height, math.NewInt(1234), []byte("queryid3"), []byte("hashId3"))
+	s.NoError(err)
+
+	reporterStake, err = rk.ReporterStake(ctx, reporter, []byte("queryid4"))
+	s.NoError(err)
+	stakeleft -= 1234
+	s.Equal(math.NewInt(int64(stakeleft)), reporterStake)
+	// -------------------------------------------------
+	err = rk.EscrowReporterStake(ctx, reporter, reporterStake.Quo(layertypes.PowerReduction).Uint64(), height, math.NewInt(85023), []byte("queryid4"), []byte("hashId4"))
+	s.NoError(err)
+
+	reporterStake, err = rk.ReporterStake(ctx, reporter, []byte("queryid5"))
+	s.NoError(err)
+	stakeleft -= 85023
+	s.Equal(math.NewInt(int64(stakeleft)), reporterStake)
+	// -------------------------------------------------
+	rPower := reporterStake.Quo(layertypes.PowerReduction)
+	err = rk.EscrowReporterStake(ctx, reporter, rPower.Uint64(), height, rPower.Mul(layertypes.PowerReduction), []byte("queryid5"), []byte("hashId5"))
+	s.NoError(err)
+
+	reporterStake, err = rk.ReporterStake(ctx, reporter, []byte("queryid6"))
+	s.NoError(err)
+	s.True(reporterStake.LT(math.NewIntWithDecimal(1, 6)))
+	// leftover less than 1 trb
+	leftover := reporterStake.ToLegacyDec().Sub(reporterStake.Quo(layertypes.PowerReduction).ToLegacyDec()).TruncateInt()
+	fmt.Println(reporterStake)
+	s.Equal(leftover, reporterStake)
+}
diff --git a/tests/setup.go b/tests/setup.go
index 90bd62a53..c06fabc9f 100644
--- a/tests/setup.go
+++ b/tests/setup.go
@@ -390,7 +390,7 @@ func (s *SharedSetup) ConvertToAccAddress(priv []ed25519.PrivKey) []sdk.AccAddre
 	return testAddrs
 }
 
-func (s *SharedSetup) CreateReporter(ctx sdk.Context, accAddr sdk.AccAddress, commissionRate math.Uint, minTokensRequired math.Int) (reportertypes.OracleReporter, error) {
+func (s *SharedSetup) CreateReporter(ctx sdk.Context, accAddr sdk.AccAddress, commissionRate math.LegacyDec, minTokensRequired math.Int) (reportertypes.OracleReporter, error) {
 	msgCreateReporter := reportertypes.MsgCreateReporter{
 		ReporterAddress:   accAddr.String(),
 		CommissionRate:    commissionRate,
diff --git a/x/dispute/types/legacy_dec.go b/types/legacy_dec.go
similarity index 100%
rename from x/dispute/types/legacy_dec.go
rename to types/legacy_dec.go
diff --git a/x/oracle/keeper/aggregate.go b/x/oracle/keeper/aggregate.go
index 36ff14500..d86ee11a6 100644
--- a/x/oracle/keeper/aggregate.go
+++ b/x/oracle/keeper/aggregate.go
@@ -47,7 +47,7 @@ func (k Keeper) SetAggregatedReport(ctx context.Context) (err error) {
 		if err != nil {
 			return err
 		}
-
+		// enter if query has expired
 		if query.Expiration <= blockHeight {
 
 			reportsIterator, err := k.Reports.Indexes.Id.MatchExact(ctx, query.Id)
@@ -96,6 +96,7 @@ func (k Keeper) SetAggregatedReport(ctx context.Context) (err error) {
 		return nil
 	}
 	// Process time-based rewards for reporters.
+	// tbr is in loya
 	tbr := k.GetTimeBasedRewards(ctx)
 	// Allocate time-based rewards to all eligible reporters.
 	return k.AllocateRewards(ctx, reportersToPay, tbr, minttypes.TimeBasedRewards)
diff --git a/x/oracle/keeper/rewards.go b/x/oracle/keeper/rewards.go
index c41f6f0cd..f19242e23 100644
--- a/x/oracle/keeper/rewards.go
+++ b/x/oracle/keeper/rewards.go
@@ -72,24 +72,25 @@ func (k Keeper) AllocateRewards(ctx context.Context, reports []*types.Aggregate,
 	})
 
 	// Process rewards in deterministic order
-	totaldist := math.ZeroUint()
+	totaldist := math.LegacyZeroDec()
 	for i, reporter := range sortedReporters {
 		amount := CalculateRewardAmount(
 			reporter.data.Power,
 			reporter.data.Reports,
 			totalPower,
+			// reward is in loya
 			reward,
 		)
-		totaldist = totaldist.Add(amount.Value)
+		totaldist = totaldist.Add(amount)
 
 		reporterAddr, err := sdk.AccAddressFromBech32(reporter.address)
 		if err != nil {
 			return err
 		}
 
-		// Handle final reporter
+		// final reporter gets total reward - total distributed so far
 		if i == len(sortedReporters)-1 {
-			amount.Value = amount.Value.Add(math.NewUint(reward.Uint64()).MulUint64(1e6)).Sub(totaldist)
+			amount = amount.Add(math.LegacyNewDecFromInt(reward).Sub(totaldist))
 		}
 
 		err = k.AllocateTip(ctx, reporterAddr.Bytes(), reporter.data.queryId, amount, reporter.data.Height)
@@ -116,13 +117,18 @@ func (k Keeper) GetTimeBasedRewardsAccount(ctx context.Context) sdk.ModuleAccoun
 	return k.accountKeeper.GetModuleAccount(ctx, minttypes.TimeBasedRewards)
 }
 
-func CalculateRewardAmount(reporterPower, reportsCount, totalPower uint64, reward math.Int) reportertypes.BigUint {
-	norm_reward := math.NewUint(reward.Uint64())
-	norm_reward = norm_reward.MulUint64(reporterPower).MulUint64(reportsCount).MulUint64(1e6)
-	amount := norm_reward.Quo(math.NewUint(totalPower))
-	return reportertypes.BigUint{Value: amount}
+func CalculateRewardAmount(reporterPower, reportsCount, totalPower uint64, reward math.Int) math.LegacyDec {
+	rPower := math.LegacyNewDec(int64(reporterPower))
+	rcount := math.LegacyNewDec(int64(reportsCount))
+	tPower := math.LegacyNewDec(int64(totalPower))
+
+	power := rPower.Mul(rcount)
+	// reward is in loya
+	// amount = (power/TotalPower) * reward
+	amount := power.Quo(tPower).Mul(reward.ToLegacyDec())
+	return amount
 }
 
-func (k Keeper) AllocateTip(ctx context.Context, addr, queryId []byte, amount reportertypes.BigUint, height uint64) error {
+func (k Keeper) AllocateTip(ctx context.Context, addr, queryId []byte, amount math.LegacyDec, height uint64) error {
 	return k.reporterKeeper.DivvyingTips(ctx, addr, amount, queryId, height)
 }
diff --git a/x/oracle/keeper/rewards_test.go b/x/oracle/keeper/rewards_test.go
index 14c6912be..3657d84d6 100644
--- a/x/oracle/keeper/rewards_test.go
+++ b/x/oracle/keeper/rewards_test.go
@@ -1,7 +1,6 @@
 package keeper_test
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -9,7 +8,6 @@ import (
 	minttypes "github.com/tellor-io/layer/x/mint/types"
 	"github.com/tellor-io/layer/x/oracle/keeper"
 	"github.com/tellor-io/layer/x/oracle/types"
-	reportertypes "github.com/tellor-io/layer/x/reporter/types"
 
 	"cosmossdk.io/math"
 
@@ -26,76 +24,73 @@ func TestCalculateRewardAmount(t *testing.T) {
 		reporterPowers []uint64
 		totalPower     uint64
 		reportsCount   uint64
-		expectedAmount []reportertypes.BigUint
+		expectedAmount []math.LegacyDec
 	}{
 		{
 			name:           "Test all reporters report",
 			reporter:       []keeper.ReportersReportCount{{Power: 10, Reports: 1}, {Power: 20, Reports: 1}, {Power: 30, Reports: 1}, {Power: 40, Reports: 1}},
-			expectedAmount: []reportertypes.BigUint{{Value: math.NewUint(10 * 1e6)}, {Value: math.NewUint(20 * 1e6)}, {Value: math.NewUint(30 * 1e6)}, {Value: math.NewUint(40 * 1e6)}},
+			expectedAmount: []math.LegacyDec{math.LegacyNewDec(10), math.LegacyNewDec(20), math.LegacyNewDec(30), math.LegacyNewDec(40)},
 			totalPower:     100, // 40 + 30 + 20 + 10
 
 		},
 		{
 			name:           "only 1 reports",
 			reporter:       []keeper.ReportersReportCount{{Power: 10, Reports: 1}, {Power: 20, Reports: 0}, {Power: 30, Reports: 0}, {Power: 40, Reports: 0}},
-			expectedAmount: []reportertypes.BigUint{{Value: math.NewUint(100 * 1e6)}, {Value: math.NewUint(0)}, {Value: math.NewUint(0)}, {Value: math.NewUint(0)}},
+			expectedAmount: []math.LegacyDec{math.LegacyNewDec(100), math.LegacyNewDec(0), math.LegacyNewDec(0), math.LegacyNewDec(0)},
 			totalPower:     10,
 		},
 		{
 			name:           "only 1 and 3 reports one report, a single queryId",
 			reporter:       []keeper.ReportersReportCount{{Power: 10, Reports: 1}, {Power: 20, Reports: 0}, {Power: 30, Reports: 1}, {Power: 40, Reports: 0}},
-			expectedAmount: []reportertypes.BigUint{{Value: math.NewUint(25 * 1e6)}, {Value: math.NewUint(0)}, {Value: math.NewUint(75 * 1e6)}, {Value: math.NewUint(0)}},
+			expectedAmount: []math.LegacyDec{math.LegacyNewDec(25), math.LegacyNewDec(0), math.LegacyNewDec(75), math.LegacyNewDec(0)},
 			totalPower:     40, // 30 + 10
 		},
 		{
 			name:           "all reporters report, a two queryIds",
 			reporter:       []keeper.ReportersReportCount{{Power: 10, Reports: 2}, {Power: 20, Reports: 2}, {Power: 30, Reports: 2}, {Power: 40, Reports: 2}},
-			expectedAmount: []reportertypes.BigUint{{Value: math.NewUint(10 * 1e6)}, {Value: math.NewUint(20 * 1e6)}, {Value: math.NewUint(30 * 1e6)}, {Value: math.NewUint(40 * 1e6)}},
+			expectedAmount: []math.LegacyDec{math.LegacyNewDec(10), math.LegacyNewDec(20), math.LegacyNewDec(30), math.LegacyNewDec(40)},
 			totalPower:     200,
 		},
 		{
 			name:     "all reporters report single, and 1 reports two queryIds",
 			reporter: []keeper.ReportersReportCount{{Power: 10, Reports: 2}, {Power: 20, Reports: 1}, {Power: 30, Reports: 1}, {Power: 40, Reports: 1}},
-			expectedAmount: []reportertypes.BigUint{
+			expectedAmount: []math.LegacyDec{
 				// power*reports/totalPower*reward
-				{Value: math.NewUint((10 * 2 * 100) * 1e6).Quo(math.NewUint(110))},
-				{Value: math.NewUint((20 * 100) * 1e6).Quo(math.NewUint(110))},
-				{Value: math.NewUint((30 * 100) * 1e6).Quo(math.NewUint(110))},
-				{Value: math.NewUint((40 * 100) * 1e6).Quo(math.NewUint(110))},
+				math.LegacyNewDec(10 * 2).Quo(math.LegacyNewDec(110)).Mul(math.LegacyNewDec(100)),
+				math.LegacyNewDec(20).Quo(math.LegacyNewDec(110)).Mul(math.LegacyNewDec(100)),
+				math.LegacyNewDec(30).Quo(math.LegacyNewDec(110)).Mul(math.LegacyNewDec(100)),
+				math.LegacyNewDec(40).Quo(math.LegacyNewDec(110)).Mul(math.LegacyNewDec(100)),
 			},
 			totalPower: 110, // 40 + 30 + 20 + (10 * 2)
 		},
 		{
 			name:     "all reporters report single, 1 and 3 report a second queryId",
 			reporter: []keeper.ReportersReportCount{{Power: 10, Reports: 2}, {Power: 20, Reports: 1}, {Power: 30, Reports: 2}, {Power: 40, Reports: 1}},
-			expectedAmount: []reportertypes.BigUint{
-				{Value: math.NewUint(14285714)},
-				{Value: math.NewUint(14285714)}, // 285714285700
-				{Value: math.NewUint(42857142)}, // 857142857100
-				{Value: math.NewUint(28571428)}, // 571428571400
+			expectedAmount: []math.LegacyDec{
+				math.LegacyMustNewDecFromStr("14.285714285714285700"),
+				math.LegacyMustNewDecFromStr("14.285714285714285700"),
+				math.LegacyMustNewDecFromStr("42.857142857142857100"),
+				math.LegacyMustNewDecFromStr("28.571428571428571400"),
 			},
 			totalPower: 140, // 40 + (30 * 2) + 20 + (10 * 2)
 		},
 	}
 	for _, tc := range testCases {
-		fmt.Println("Start of test case")
-		expectedTotalReward := math.ZeroUint()
-		totaldist := math.ZeroUint()
+		expectedTotalReward := math.LegacyZeroDec()
+		totaldist := math.LegacyZeroDec()
 		t.Run(tc.name, func(t *testing.T) {
 			for i, r := range tc.reporter {
 				amount := keeper.CalculateRewardAmount(r.Power, r.Reports, tc.totalPower, reward)
-				fmt.Println("Reward amount: ", amount.Value.String())
-				totaldist = totaldist.Add(amount.Value)
-				fmt.Println("TotalDist: ", totaldist.String())
+				totaldist = totaldist.Add(amount)
 				require.Equal(t, amount, tc.expectedAmount[i])
 				if i == len(tc.reporter)-1 {
-					amount.Value = amount.Value.Add(math.NewUint(reward.Uint64() * 1e6)).Sub(totaldist)
+					amount = amount.Add(math.LegacyNewDecFromInt(reward).Sub(totaldist))
 				}
-				expectedTotalReward = expectedTotalReward.Add(amount.Value)
-				fmt.Println("Expected total reward: ", expectedTotalReward.String())
+				expectedTotalReward = expectedTotalReward.Add(amount)
+
 			}
 		})
-		require.True(t, expectedTotalReward.Equal(math.NewUint(reward.Uint64()*1e6)), "reward amount should be within tolerance")
+		require.True(t, expectedTotalReward.Equal(math.LegacyNewDecFromInt(reward)), "reward amount should be within tolerance")
 	}
 }
 
@@ -142,8 +137,9 @@ func (s *KeeperTestSuite) TestAllocateRewards() {
 	require.NoError(err)
 	rep2Addr, err := sdk.AccAddressFromBech32(rep2)
 	require.NoError(err)
-	rk.On("DivvyingTips", ctx, rep1Addr, reportertypes.BigUint{Value: math.NewUint(50000000)}, []byte{}, uint64(0)).Return(nil).Once()
-	rk.On("DivvyingTips", ctx, rep2Addr, reportertypes.BigUint{Value: math.NewUint(50000000)}, []byte{}, uint64(0)).Return(nil).Once()
+
+	rk.On("DivvyingTips", ctx, rep1Addr, math.LegacyNewDec(50), []byte{}, uint64(0)).Return(nil).Once()
+	rk.On("DivvyingTips", ctx, rep2Addr, math.LegacyNewDec(50), []byte{}, uint64(0)).Return(nil).Once()
 	bk.On("SendCoinsFromModuleToModule", ctx, "oracle", "tips_escrow_pool", sdk.NewCoins(sdk.NewCoin("loya", reward))).Return(nil)
 	require.NoError(k.AllocateRewards(ctx, reporters, reward, types.ModuleName))
 }
@@ -186,6 +182,7 @@ func (s *KeeperTestSuite) TestGetTimeBasedRewardsAccount() {
 	require.Equal(k.GetTimeBasedRewardsAccount(ctx), testModuleAccount)
 }
 
+// TODO: add scenarios
 func (s *KeeperTestSuite) TestAllocateTips() {
 	require := s.Require()
 	k := s.oracleKeeper
@@ -193,7 +190,7 @@ func (s *KeeperTestSuite) TestAllocateTips() {
 	ctx := s.ctx
 
 	addr := sample.AccAddressBytes()
-	amount := reportertypes.BigUint{Value: math.NewUint(100)}
+	amount := math.LegacyNewDec(100)
 	rk.On("DivvyingTips", ctx, addr, amount, []byte{}, uint64(ctx.BlockHeight())).Return(nil).Once()
 	require.NoError(k.AllocateTip(ctx, addr, []byte{}, amount, uint64(ctx.BlockHeight())))
 }
diff --git a/x/oracle/mocks/ReporterKeeper.go b/x/oracle/mocks/ReporterKeeper.go
index 9838faf08..d94154314 100644
--- a/x/oracle/mocks/ReporterKeeper.go
+++ b/x/oracle/mocks/ReporterKeeper.go
@@ -9,8 +9,6 @@ import (
 
 	mock "github.com/stretchr/testify/mock"
 
-	reportertypes "github.com/tellor-io/layer/x/reporter/types"
-
 	types "github.com/cosmos/cosmos-sdk/types"
 )
 
@@ -20,11 +18,11 @@ type ReporterKeeper struct {
 }
 
 // DivvyingTips provides a mock function with given fields: ctx, reporterAddr, reward, queryId, height
-func (_m *ReporterKeeper) DivvyingTips(ctx context.Context, reporterAddr types.AccAddress, reward reportertypes.BigUint, queryId []byte, height uint64) error {
+func (_m *ReporterKeeper) DivvyingTips(ctx context.Context, reporterAddr types.AccAddress, reward math.LegacyDec, queryId []byte, height uint64) error {
 	ret := _m.Called(ctx, reporterAddr, reward, queryId, height)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, reportertypes.BigUint, []byte, uint64) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, math.LegacyDec, []byte, uint64) error); ok {
 		r0 = rf(ctx, reporterAddr, reward, queryId, height)
 	} else {
 		r0 = ret.Error(0)
diff --git a/x/oracle/types/expected_keepers.go b/x/oracle/types/expected_keepers.go
index 20d0641b9..2cb7f1d51 100644
--- a/x/oracle/types/expected_keepers.go
+++ b/x/oracle/types/expected_keepers.go
@@ -4,7 +4,6 @@ import (
 	context "context"
 
 	rktypes "github.com/tellor-io/layer/x/registry/types"
-	reptypes "github.com/tellor-io/layer/x/reporter/types"
 
 	"cosmossdk.io/math"
 
@@ -35,7 +34,7 @@ type RegistryKeeper interface {
 type ReporterKeeper interface {
 	// Methods imported from reporter should be defined here
 	ReporterStake(ctx context.Context, repAddress sdk.AccAddress, queryId []byte) (math.Int, error)
-	DivvyingTips(ctx context.Context, reporterAddr sdk.AccAddress, reward reptypes.BigUint, queryId []byte, height uint64) error
+	DivvyingTips(ctx context.Context, reporterAddr sdk.AccAddress, reward math.LegacyDec, queryId []byte, height uint64) error
 }
 
 type RegistryHooks interface {
diff --git a/x/registry/types/decoding.go b/x/registry/types/decoding.go
index c7dbc0430..6ebefbbf9 100644
--- a/x/registry/types/decoding.go
+++ b/x/registry/types/decoding.go
@@ -13,7 +13,6 @@ func IsValueDecodable(value, datatype string) error {
 	if err != nil {
 		return fmt.Errorf("failed to unpack value: %w", err)
 	}
-	// fmt.Println("Decoded value: ", result[0]) todo: do we still need this ?
 	return nil
 }
 
diff --git a/x/reporter/keeper/distribution.go b/x/reporter/keeper/distribution.go
index 4c3717e6a..5d898cc1c 100644
--- a/x/reporter/keeper/distribution.go
+++ b/x/reporter/keeper/distribution.go
@@ -6,8 +6,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/tellor-io/layer/x/reporter/types"
-
 	"cosmossdk.io/collections"
 	"cosmossdk.io/math"
 
@@ -27,23 +25,16 @@ import (
 // 5. Distributes the net reward among the selectors based on their shares.
 // 6. Adds the commission to the reporter's share if the reporter is also a selector.
 // 7. Updates the selectors' tips with the new calculated shares.
-func (k Keeper) DivvyingTips(ctx context.Context, reporterAddr sdk.AccAddress, reward types.BigUint, queryId []byte, height uint64) error {
+func (k Keeper) DivvyingTips(ctx context.Context, reporterAddr sdk.AccAddress, reward math.LegacyDec, queryId []byte, height uint64) error {
 	reporter, err := k.Reporters.Get(ctx, reporterAddr)
 	if err != nil {
 		return err
 	}
 
-	// Convert arguments needed for calculations to legacy decimals
-	rewardDec := k.LegacyDecFromMathUint(reward.Value)
-	commissionRateDec := k.LegacyDecFromMathUint(reporter.CommissionRate)
-
-	// Calculate commission: commission = reward * commissionRate
-	commissionDec := rewardDec.Mul(commissionRateDec).Quo(math.LegacyNewDec(1000000))
-
-	commission := k.TruncateUint(commissionDec)
-
+	// selector's commission = reporter's commission rate * reward
+	commission := reward.Mul(reporter.CommissionRate)
 	// Calculate net reward
-	netReward := reward.Value.Sub(commission)
+	netReward := reward.Sub(commission)
 
 	delAddrs, err := k.Report.Get(ctx, collections.Join(queryId, collections.Join(reporterAddr.Bytes(), height)))
 	if err != nil {
@@ -51,25 +42,26 @@ func (k Keeper) DivvyingTips(ctx context.Context, reporterAddr sdk.AccAddress, r
 	}
 
 	for _, del := range delAddrs.TokenOrigins {
-		// convert args needed for calculations to legacy decimals
-		netRewardDec := k.LegacyDecFromMathUint(netReward)
-		delAmountDec := math.LegacyNewDecFromInt(del.Amount)
-		delTotalDec := math.LegacyNewDecFromInt(delAddrs.Total)
-		delegatorShareDec := netRewardDec.Mul(delAmountDec).Quo(delTotalDec)
-		delegatorShare := k.TruncateUint(delegatorShareDec)
+		// delegator share = netReward * selector's share / total shares
+		delAmountDec := del.Amount.ToLegacyDec()
+		delTotalDec := delAddrs.Total.ToLegacyDec()
+		delegatorShare := netReward.Mul(delAmountDec).Quo(delTotalDec)
+
 		if bytes.Equal(del.DelegatorAddress, reporterAddr.Bytes()) {
 			delegatorShare = delegatorShare.Add(commission)
 		}
-		// get selector's tips and add the new tip
+		// get selector's previous tips
 		oldTips, err := k.SelectorTips.Get(ctx, del.DelegatorAddress)
 		if err != nil {
 			if errors.Is(err, collections.ErrNotFound) {
-				oldTips = types.BigUint{Value: math.ZeroUint()}
+				oldTips = math.LegacyZeroDec()
 			} else {
 				return err
 			}
 		}
-		newTips := types.BigUint{Value: oldTips.Value.Add(delegatorShare)}
+		// add the new tip to the old tips
+		newTips := oldTips.Add(delegatorShare)
+		// set new tip total
 		err = k.SelectorTips.Set(ctx, del.DelegatorAddress, newTips)
 		if err != nil {
 			return err
@@ -115,14 +107,10 @@ func (k Keeper) ReturnSlashedTokens(ctx context.Context, amt math.Int, hashId []
 
 		// the refund amount is either the amount of tokens that were slashed
 		// or the proportion of the slashed tokens plus the winning purse
-		shareAmt := math.NewUint(source.Amount.Uint64())
+		shareAmt := math.LegacyNewDecFromInt(source.Amount)
 		if winningpurse.IsPositive() {
 			// convert args needed for calculations to legacy decimals
-			sourceAmountDec := math.LegacyNewDecFromInt(source.Amount)
-			amountDec := math.LegacyNewDecFromInt(amt)
-			snapshotTotalDec := math.LegacyNewDecFromInt(snapshot.Total)
-			shareAmtDec := sourceAmountDec.Mul(amountDec).Quo(snapshotTotalDec)
-			shareAmt = k.TruncateUint(shareAmtDec)
+			shareAmt = shareAmt.Quo(math.LegacyNewDecFromInt(snapshot.Total)).Mul(math.LegacyNewDecFromInt(amt))
 		}
 		// set token source to bonded if validator is bonded
 		// if not, set to unbonded
@@ -134,11 +122,10 @@ func (k Keeper) ReturnSlashedTokens(ctx context.Context, amt math.Int, hashId []
 		} else {
 			tokenSrc = stakingtypes.Unbonded
 		}
-		_, err = k.stakingKeeper.Delegate(ctx, delAddr, math.NewInt(int64(shareAmt.Uint64())), tokenSrc, val, false) // false means to not subtract tokens from an account
+		_, err = k.stakingKeeper.Delegate(ctx, delAddr, shareAmt.TruncateInt(), tokenSrc, val, false) // false means to not subtract tokens from an account
 		if err != nil {
 			return err
 		}
-
 	}
 
 	return k.DisputedDelegationAmounts.Remove(ctx, hashId)
@@ -235,13 +222,3 @@ func (k Keeper) AddAmountToStake(ctx context.Context, acc sdk.AccAddress, amt ma
 	}
 	return nil
 }
-
-// Converts a math.Uint to a legacy decimal
-func (k Keeper) LegacyDecFromMathUint(value math.Uint) math.LegacyDec {
-	return math.LegacyNewDecFromInt(math.NewIntFromUint64(value.Uint64()))
-}
-
-// Truncates a legacy decimal to a math.Uint
-func (k Keeper) TruncateUint(value math.LegacyDec) math.Uint {
-	return math.NewUint(value.TruncateInt().Uint64())
-}
diff --git a/x/reporter/keeper/distribution_test.go b/x/reporter/keeper/distribution_test.go
index 7ce57eb33..15e36e5c1 100644
--- a/x/reporter/keeper/distribution_test.go
+++ b/x/reporter/keeper/distribution_test.go
@@ -24,7 +24,7 @@ func TestDivvyingTips(t *testing.T) {
 	val1 := vals[0]
 	addr := sample.AccAddressBytes()
 	addr2 := sample.AccAddressBytes()
-	reporter1 := types.NewReporter(math.ZeroUint(), math.OneInt())
+	reporter1 := types.NewReporter(math.LegacyZeroDec(), math.OneInt())
 	ctx = ctx.WithBlockHeight(int64(height))
 
 	err := k.Reporters.Set(ctx, addr, reporter1)
@@ -50,7 +50,7 @@ func TestDivvyingTips(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx = ctx.WithBlockHeight(12)
-	err = k.DivvyingTips(ctx, addr, types.BigUint{Value: math.NewUint(10 * 1e6)}, []byte{}, 10)
+	err = k.DivvyingTips(ctx, addr, math.LegacyNewDec(10*1e6), []byte{}, 10)
 	require.NoError(t, err)
 
 	ctx = ctx.WithBlockHeight(13)
@@ -59,10 +59,10 @@ func TestDivvyingTips(t *testing.T) {
 	del2, err := k.SelectorTips.Get(ctx, addr2.Bytes())
 
 	fmt.Printf("delegator1: %v, delegator2: %v\r", del1, del2)
-	require.Equal(t, types.BigUint{Value: math.NewUint(5 * 1e6)}, del1)
+	require.Equal(t, math.LegacyNewDec(5*1e6), del1)
 
 	require.NoError(t, err)
-	require.Equal(t, types.BigUint{Value: math.NewUint(5 * 1e6)}, del2)
+	require.Equal(t, math.LegacyNewDec(5*1e6), del2)
 }
 
 func TestReturnSlashedTokens(t *testing.T) {
diff --git a/x/reporter/keeper/indexes_test.go b/x/reporter/keeper/indexes_test.go
index e7d550a10..c34ae0154 100644
--- a/x/reporter/keeper/indexes_test.go
+++ b/x/reporter/keeper/indexes_test.go
@@ -17,7 +17,7 @@ func TestReporterDelegatorIndex(t *testing.T) {
 
 	repAddr := sample.AccAddressBytes()
 	// set reporter
-	reporter := types.NewReporter(math.ZeroUint(), math.ZeroInt())
+	reporter := types.NewReporter(math.LegacyZeroDec(), math.ZeroInt())
 	err := k.Reporters.Set(ctx, repAddr, reporter)
 	require.NoError(t, err)
 
diff --git a/x/reporter/keeper/keeper.go b/x/reporter/keeper/keeper.go
index 2594408af..7390d83cb 100644
--- a/x/reporter/keeper/keeper.go
+++ b/x/reporter/keeper/keeper.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	layertypes "github.com/tellor-io/layer/types"
 	"github.com/tellor-io/layer/x/reporter/types"
 
 	"cosmossdk.io/collections"
@@ -24,7 +25,7 @@ type (
 		Params                    collections.Item[types.Params]
 		Tracker                   collections.Item[types.StakeTracker]
 		Reporters                 collections.Map[[]byte, types.OracleReporter]                                                                                             // key: reporter AccAddress
-		SelectorTips              collections.Map[[]byte, types.BigUint]                                                                                                    // key: selector AccAddress
+		SelectorTips              collections.Map[[]byte, math.LegacyDec]                                                                                                   // key: selector AccAddress
 		Selectors                 *collections.IndexedMap[[]byte, types.Selection, ReporterSelectorsIndex]                                                                  // key: selector AccAddress
 		DisputedDelegationAmounts collections.Map[[]byte, types.DelegationsAmounts]                                                                                         // key: dispute hashId
 		FeePaidFromStake          collections.Map[[]byte, types.DelegationsAmounts]                                                                                         // key: dispute hashId
@@ -65,7 +66,7 @@ func NewKeeper(
 		Tracker:                   collections.NewItem(sb, types.StakeTrackerPrefix, "tracker", codec.CollValue[types.StakeTracker](cdc)),
 		Reporters:                 collections.NewMap(sb, types.ReportersKey, "reporters", collections.BytesKey, codec.CollValue[types.OracleReporter](cdc)),
 		Selectors:                 collections.NewIndexedMap(sb, types.SelectorsKey, "selectors", collections.BytesKey, codec.CollValue[types.Selection](cdc), NewSelectorsIndex(sb)),
-		SelectorTips:              collections.NewMap(sb, types.SelectorTipsPrefix, "delegator_tips", collections.BytesKey, codec.CollValue[types.BigUint](cdc)),
+		SelectorTips:              collections.NewMap(sb, types.SelectorTipsPrefix, "delegator_tips", collections.BytesKey, layertypes.LegacyDecValue),
 		DisputedDelegationAmounts: collections.NewMap(sb, types.DisputedDelegationAmountsPrefix, "disputed_delegation_amounts", collections.BytesKey, codec.CollValue[types.DelegationsAmounts](cdc)),
 		FeePaidFromStake:          collections.NewMap(sb, types.FeePaidFromStakePrefix, "fee_paid_from_stake", collections.BytesKey, codec.CollValue[types.DelegationsAmounts](cdc)),
 		Report: collections.NewIndexedMap(
diff --git a/x/reporter/keeper/msg_server.go b/x/reporter/keeper/msg_server.go
index 3815dc8c7..9a6488f52 100644
--- a/x/reporter/keeper/msg_server.go
+++ b/x/reporter/keeper/msg_server.go
@@ -58,8 +58,8 @@ func (k msgServer) CreateReporter(goCtx context.Context, msg *types.MsgCreateRep
 		return nil, errors.New("address already exists")
 	}
 
-	if msg.CommissionRate.GT(math.NewUint(1e6)) {
-		return nil, errors.New("commission rate must be below 1000000 as that is a 100 percent commission rate")
+	if msg.CommissionRate.GT(math.LegacyNewDec(100)) {
+		return nil, errors.New("commission rate must be LTE 100 as that is a 100 percent commission rate")
 	}
 	// set the reporter and set the self selector
 	if err := k.Keeper.Reporters.Set(goCtx, addr.Bytes(), types.NewReporter(msg.CommissionRate, msg.MinTokensRequired)); err != nil {
@@ -311,25 +311,24 @@ func (k msgServer) WithdrawTip(goCtx context.Context, msg *types.MsgWithdrawTip)
 	if !val.IsBonded() {
 		return nil, errors.New("chosen validator must be bonded")
 	}
-	sharesDec := k.LegacyDecFromMathUint(shares.Value)
-	amtToDelegateDec := sharesDec.Quo(math.LegacyNewDec(1e6))
-	amtToDelegate := k.TruncateUint(amtToDelegateDec)
+	amtToDelegate := shares.TruncateInt()
 	if amtToDelegate.IsZero() {
 		return nil, errors.New("no tips to withdraw")
 	}
-	_, err = k.Keeper.stakingKeeper.Delegate(ctx, delAddr, math.NewInt(int64(amtToDelegate.Uint64())), val.Status, val, false)
+	_, err = k.Keeper.stakingKeeper.Delegate(ctx, delAddr, amtToDelegate, val.Status, val, false)
 	if err != nil {
 		return nil, err
 	}
 
-	remainder := shares.Value.Sub(amtToDelegate.MulUint64(1e6))
+	// isolate decimals from shares
+	remainder := shares.Sub(shares.TruncateDec())
 	if remainder.IsZero() {
 		err = k.Keeper.SelectorTips.Remove(ctx, delAddr)
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		err = k.Keeper.SelectorTips.Set(ctx, delAddr, types.BigUint{Value: remainder})
+		err = k.Keeper.SelectorTips.Set(ctx, delAddr, remainder)
 		if err != nil {
 			return nil, err
 		}
diff --git a/x/reporter/keeper/msg_server_test.go b/x/reporter/keeper/msg_server_test.go
index 8af5bbba1..b8dad7db3 100644
--- a/x/reporter/keeper/msg_server_test.go
+++ b/x/reporter/keeper/msg_server_test.go
@@ -68,8 +68,8 @@ func TestCreateReporter(t *testing.T) {
 		}
 	})
 
-	_, err = ms.CreateReporter(ctx, &types.MsgCreateReporter{ReporterAddress: addr.String(), CommissionRate: math.NewUint(1e6 + 1), MinTokensRequired: types.DefaultMinTrb})
-	require.Equal(t, err.Error(), "commission rate must be below 1000000 as that is a 100 percent commission rate")
+	// _, err = ms.CreateReporter(ctx, &types.MsgCreateReporter{ReporterAddress: addr.String(), CommissionRate: math.LegacyNewDec(1e6 + 1), MinTokensRequired: types.DefaultMinTrb})
+	// require.Equal(t, err.Error(), "commission rate must be below 1000000 as that is a 100 percent commission rate")
 
 	_, err = k.Reporters.Get(ctx, addr)
 	require.ErrorIs(t, err, collections.ErrNotFound)
@@ -295,12 +295,12 @@ func TestWithdrawTip(t *testing.T) {
 	_, err := msg.WithdrawTip(ctx, &types.MsgWithdrawTip{SelectorAddress: selector.String(), ValidatorAddress: valAddr.String()})
 	require.ErrorIs(t, err, collections.ErrNotFound)
 
-	require.NoError(t, k.SelectorTips.Set(ctx, selector, types.BigUint{Value: math.NewUint(1 * 1e6)}))
+	require.NoError(t, k.SelectorTips.Set(ctx, selector, math.LegacyNewDec(1*1e6)))
 
 	validator := stakingtypes.Validator{Status: stakingtypes.Bonded}
 	sk.On("GetValidator", ctx, valAddr).Return(validator, nil)
-	sk.On("Delegate", ctx, selector, math.OneInt(), stakingtypes.Bonded, validator, false).Return(math.LegacyZeroDec(), nil)
-	bk.On("SendCoinsFromModuleToModule", ctx, types.TipsEscrowPool, stakingtypes.BondedPoolName, sdk.NewCoins(sdk.NewCoin("loya", math.OneInt()))).Return(nil)
+	sk.On("Delegate", ctx, selector, math.NewInt(1*1e6), stakingtypes.Bonded, validator, false).Return(math.LegacyZeroDec(), nil)
+	bk.On("SendCoinsFromModuleToModule", ctx, types.TipsEscrowPool, stakingtypes.BondedPoolName, sdk.NewCoins(sdk.NewCoin("loya", math.NewInt(1*1e6)))).Return(nil)
 	_, err = msg.WithdrawTip(ctx, &types.MsgWithdrawTip{SelectorAddress: selector.String(), ValidatorAddress: valAddr.String()})
 	require.NoError(t, err)
 }
diff --git a/x/reporter/keeper/query.go b/x/reporter/keeper/query.go
index 34b4173fc..40ee47f4f 100644
--- a/x/reporter/keeper/query.go
+++ b/x/reporter/keeper/query.go
@@ -149,5 +149,5 @@ func (k Querier) AvailableTips(ctx context.Context, req *types.QueryAvailableTip
 	if err != nil {
 		return nil, err
 	}
-	return &types.QueryAvailableTipsResponse{AvailableTips: rewards.Value.QuoUint64(1e6)}, nil
+	return &types.QueryAvailableTipsResponse{AvailableTips: rewards}, nil
 }
diff --git a/x/reporter/keeper/query_test.go b/x/reporter/keeper/query_test.go
index 2830bf05b..a9f7b4baf 100644
--- a/x/reporter/keeper/query_test.go
+++ b/x/reporter/keeper/query_test.go
@@ -121,7 +121,7 @@ func TestAvailableTips(t *testing.T) {
 		setup    func()
 		req      *types.QueryAvailableTipsRequest
 		err      bool
-		expected types.BigUint
+		expected math.LegacyDec
 	}{
 		{
 			name: "nil request",
@@ -132,29 +132,29 @@ func TestAvailableTips(t *testing.T) {
 			name:     "no tips",
 			req:      &types.QueryAvailableTipsRequest{SelectorAddress: selectorAddr.String()},
 			err:      true,
-			expected: types.BigUint{Value: math.ZeroUint()},
+			expected: math.LegacyZeroDec(),
 		},
 		{
 			name: "one tip",
 			setup: func() {
-				err := k.SelectorTips.Set(ctx, selectorAddr, types.BigUint{Value: math.NewUint(100 * 1e6)})
+				err := k.SelectorTips.Set(ctx, selectorAddr, math.LegacyNewDec(100*1e6))
 				require.NoError(err)
 			},
 			req:      &types.QueryAvailableTipsRequest{SelectorAddress: selectorAddr.String()},
 			err:      false,
-			expected: types.BigUint{Value: math.NewUint(100)},
+			expected: math.LegacyNewDec(100 * 1e6),
 		},
 		{
 			name: "amount changes",
 			setup: func() {
-				err := k.SelectorTips.Set(ctx, selectorAddr, types.BigUint{Value: math.NewUint(100 * 1e6)})
+				err := k.SelectorTips.Set(ctx, selectorAddr, math.LegacyNewDec(100*1e6))
 				require.NoError(err)
-				err = k.SelectorTips.Set(ctx, selectorAddr, types.BigUint{Value: math.NewUint(200 * 1e6)})
+				err = k.SelectorTips.Set(ctx, selectorAddr, math.LegacyNewDec(200*1e6))
 				require.NoError(err)
 			},
 			req:      &types.QueryAvailableTipsRequest{SelectorAddress: selectorAddr.String()},
 			err:      false,
-			expected: types.BigUint{Value: math.NewUint(200)},
+			expected: math.LegacyNewDec(200 * 1e6),
 		},
 	}
 	for _, tc := range testCases {
@@ -169,7 +169,7 @@ func TestAvailableTips(t *testing.T) {
 				require.Error(err)
 			} else {
 				require.NoError(err)
-				require.Equal(tc.expected.Value, res.AvailableTips)
+				require.Equal(tc.expected, res.AvailableTips)
 			}
 		})
 	}
diff --git a/x/reporter/keeper/withdraw.go b/x/reporter/keeper/withdraw.go
index 7fa40f9d8..d5a313ce6 100644
--- a/x/reporter/keeper/withdraw.go
+++ b/x/reporter/keeper/withdraw.go
@@ -179,19 +179,13 @@ func (k Keeper) EscrowReporterStake(ctx context.Context, reporterAddr sdk.AccAdd
 
 	totalTokens := layertypes.PowerReduction.MulRaw(int64(power))
 	disputeTokens := make([]*types.TokenOriginInfo, 0)
-	leftover := math.NewUint(amt.Uint64() * 1e6)
+	leftover := amt
 	// loop through the selectors' tokens (validator, amount) that were part of the report and remove tokens from relevant delegations
 	// amount should be proportional to the total tokens the reporter had at the time of the report
 	for i, del := range report.TokenOrigins {
-		truncDelAmount := math.NewUint(del.Amount.Uint64()).QuoUint64(layertypes.PowerReduction.Uint64()).MulUint64(layertypes.PowerReduction.Uint64())
-		// convert args needed for calculations to legacy decimals
-		truncDelAmountDec := k.LegacyDecFromMathUint(truncDelAmount)
-		amtDec := math.LegacyNewDecFromInt(amt)
-		powerReductionDec := math.LegacyNewDecFromInt(layertypes.PowerReduction)
-		totalTokensDec := math.LegacyNewDecFromInt(totalTokens)
-		delegatorShareDec := truncDelAmountDec.Mul(amtDec).Mul(powerReductionDec).Quo(totalTokensDec)
-		delegatorShare := k.TruncateUint(delegatorShareDec)
+		delegatorShare := math.LegacyNewDecFromInt(del.Amount).Quo(math.LegacyNewDecFromInt(totalTokens)).Mul(math.LegacyNewDecFromInt(amt)).RoundInt()
 		leftover = leftover.Sub(delegatorShare)
+
 		// leftover amount is taken from the last selector in the iteration
 		if i == len(report.TokenOrigins)-1 {
 			delegatorShare = delegatorShare.Add(leftover)
@@ -200,38 +194,33 @@ func (k Keeper) EscrowReporterStake(ctx context.Context, reporterAddr sdk.AccAdd
 		delAddr := sdk.AccAddress(del.DelegatorAddress)
 		valAddr := sdk.ValAddress(del.ValidatorAddress)
 
-		remaining, err := k.undelegate(ctx, delAddr, valAddr, delegatorShare)
+		remaining, err := k.undelegate(ctx, delAddr, valAddr, delegatorShare.ToLegacyDec())
 		if err != nil {
 			return err
 		}
-		storedAmount := delegatorShare.Sub(math.NewUint(remaining.Uint64()))
-		storedAmountDec := k.LegacyDecFromMathUint(storedAmount)
-		storedAmountFixed6Dec := storedAmountDec.Quo(powerReductionDec)
-		storedAmountFixed6 := k.TruncateUint(storedAmountFixed6Dec)
+
+		storedAmount := delegatorShare.Sub(remaining)
 		if !storedAmount.IsZero() {
 			disputeTokens = append(disputeTokens, &types.TokenOriginInfo{
 				DelegatorAddress: del.DelegatorAddress,
 				ValidatorAddress: del.ValidatorAddress,
-				Amount:           math.NewIntFromUint64(storedAmountFixed6.Uint64()),
+				Amount:           storedAmount,
 			})
 		}
 
-		remainingDec := k.LegacyDecFromMathUint(remaining)
-		remainingFixed6Dec := remainingDec.Quo(powerReductionDec)
-		remainingFixed6 := k.TruncateUint(remainingFixed6Dec)
 		if !remaining.IsZero() {
 			dstVAl, err := k.getDstValidator(ctx, delAddr, valAddr)
 			if err != nil {
 				return err
 			}
-			_, err = k.undelegate(ctx, delAddr, dstVAl, remaining)
+			_, err = k.undelegate(ctx, delAddr, dstVAl, math.LegacyNewDecFromInt(remaining))
 			if err != nil {
 				return err
 			}
 			disputeTokens = append(disputeTokens, &types.TokenOriginInfo{
 				DelegatorAddress: del.DelegatorAddress,
 				ValidatorAddress: dstVAl,
-				Amount:           math.NewIntFromUint64(remainingFixed6.Uint64()),
+				Amount:           remaining,
 			})
 		}
 	}
@@ -259,35 +248,26 @@ func (k Keeper) getDstValidator(ctx context.Context, delAddr sdk.AccAddress, val
 }
 
 // chases after unbonding delegations in order to get tokens that are part a new dispute
-func (k Keeper) deductUnbondingDelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, tokens math.Uint) (math.Uint, error) {
+func (k Keeper) deductUnbondingDelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, tokens math.Int) (math.Int, error) {
 	ubd, err := k.stakingKeeper.GetUnbondingDelegation(ctx, delAddr, valAddr)
 	if err != nil {
-		return math.Uint{}, err
+		return math.Int{}, err
 	}
-
 	if len(ubd.Entries) == 0 {
-		return math.Uint{}, types.ErrNoUnbondingDelegationEntries
+		return math.Int{}, types.ErrNoUnbondingDelegationEntries
 	}
-	removeAmt := math.ZeroUint()
+	removeAmt := math.ZeroInt()
 	for i, u := range ubd.Entries {
-		normalizedBalance := math.NewUint(u.Balance.Uint64() * 1e6)
-		if normalizedBalance.LT(tokens) {
-			tokens = tokens.Sub(normalizedBalance)
-			removeAmt = removeAmt.Add(normalizedBalance)
+		if u.Balance.LT(tokens) {
+			tokens = tokens.Sub(u.Balance)
+			removeAmt = removeAmt.Add(u.Balance)
 			ubd.RemoveEntry(int64(i))
 		} else {
-			normalizedBalanceDec := k.LegacyDecFromMathUint(normalizedBalance)
-			tokensDec := k.LegacyDecFromMathUint(tokens)
-			powerReductionDec := math.LegacyNewDecFromInt(layertypes.PowerReduction)
-			uBalanceDec := normalizedBalanceDec.Sub(tokensDec).Quo(powerReductionDec)
-			u.Balance = uBalanceDec.TruncateInt()
-
-			uInitialBalanceDec := math.LegacyNewDecFromInt(u.InitialBalance)
-			uInitialBalanceDec = uInitialBalanceDec.Sub(tokensDec.Quo(powerReductionDec))
-			u.InitialBalance = uInitialBalanceDec.TruncateInt()
+			u.Balance = u.Balance.Sub(tokens)
+			u.InitialBalance = u.InitialBalance.Sub(tokens)
 			ubd.Entries[i] = u
 			removeAmt = removeAmt.Add(tokens)
-			tokens = math.ZeroUint()
+			tokens = math.ZeroInt()
 			break
 		}
 	}
@@ -298,61 +278,53 @@ func (k Keeper) deductUnbondingDelegation(ctx context.Context, delAddr sdk.AccAd
 		err = k.stakingKeeper.SetUnbondingDelegation(ctx, ubd)
 	}
 	if err != nil {
-		return math.Uint{}, err
+		return math.Int{}, err
 	}
-	removeAmtDec := k.LegacyDecFromMathUint(removeAmt)
-	powerReductionDec := math.LegacyNewDecFromInt(layertypes.PowerReduction)
-	disputeAmtDec := removeAmtDec.Quo(powerReductionDec)
-	disputeAmt := disputeAmtDec.TruncateInt()
-	err = k.tokensToDispute(ctx, stakingtypes.NotBondedPoolName, disputeAmt)
+
+	err = k.tokensToDispute(ctx, stakingtypes.NotBondedPoolName, removeAmt)
 	if err != nil {
-		return math.Uint{}, err
+		return math.Int{}, err
 	}
 	return tokens, nil
 }
 
-func (k Keeper) deductFromdelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, delTokens math.Uint) (math.Uint, error) {
+func (k Keeper) deductFromdelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, delTokens math.LegacyDec) (math.LegacyDec, error) {
 	// get delegation
 	del, err := k.stakingKeeper.GetDelegation(ctx, delAddr, valAddr)
 	if err != nil {
 		if errors.Is(err, stakingtypes.ErrNoDelegation) {
 			return delTokens, nil
 		}
-		return math.Uint{}, err
+		return math.LegacyDec{}, err
 	}
 	validator, err := k.stakingKeeper.GetValidator(ctx, valAddr)
 	if err != nil {
-		return math.Uint{}, err
+		return math.LegacyDec{}, err
 	}
 
 	// convert current delegation shares to tokens
 	currentTokens := validator.TokensFromShares(del.Shares)
-	tokensFromShare := math.NewUint(currentTokens.BigInt().Uint64() * 1e6) // normalize to match with the normalized delTokens
 	shares := del.Shares
-	if tokensFromShare.GTE(delTokens) {
-		delTokensDec := k.LegacyDecFromMathUint(delTokens)
-		powerReductionDec := math.LegacyNewDecFromInt(layertypes.PowerReduction)
-		tokensAmtDec := delTokensDec.Quo(powerReductionDec)
-		shares, err = validator.SharesFromTokens(tokensAmtDec.TruncateInt())
+	if currentTokens.GTE(delTokens) {
+		shares, err = validator.SharesFromTokens(delTokens.RoundInt())
 		if err != nil {
-			return math.Uint{}, err
+			return math.LegacyDec{}, err
 		}
-		delTokens = math.ZeroUint()
+		delTokens = math.LegacyZeroDec()
 	} else {
-		delTokens = delTokens.Sub(tokensFromShare)
+		delTokens = delTokens.Sub(currentTokens)
 	}
 
-	if !tokensFromShare.IsZero() {
+	if !shares.IsZero() {
 		removedTokens, err := k.stakingKeeper.Unbond(ctx, delAddr, valAddr, shares)
 		if err != nil {
-			return math.Uint{}, err
+			return math.LegacyDec{}, err
 		}
 		err = k.MoveTokensFromValidator(ctx, validator, removedTokens)
 		if err != nil {
-			return math.Uint{}, err
+			return math.LegacyDec{}, err
 		}
 	}
-	// returning normalized version of delTokens
 	return delTokens, nil
 }
 
@@ -370,34 +342,32 @@ func (k Keeper) MoveTokensFromValidator(ctx context.Context, validator stakingty
 }
 
 func (k Keeper) tokensToDispute(ctx context.Context, fromPool string, amount math.Int) error {
-	fmt.Println("Tokens to dispute: ", amount)
 	return k.bankKeeper.SendCoinsFromModuleToModule(ctx, fromPool, disputetypes.ModuleName, sdk.NewCoins(sdk.NewCoin(layertypes.BondDenom, amount)))
 }
 
 // undelegate a selector's tokens that are part of a dispute.
 // first attempt to get the tokens from known validator and if not found then chase after the tokens that were either redelegated to another validator
 // or are being unbonded
-func (k Keeper) undelegate(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, delTokens math.Uint) (math.Uint, error) {
+func (k Keeper) undelegate(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, delTokens math.LegacyDec) (math.Int, error) {
 	remainingFromdel, err := k.deductFromdelegation(ctx, delAddr, valAddr, delTokens)
 	if err != nil {
-		return math.Uint{}, err
+		return math.Int{}, err
 	}
-
 	// if tokens are still remaining after removing from delegation, then it could be one of two cases
 	// the delegator is unbonding or the delegator has redelegated to another validator
 	if remainingFromdel.IsZero() {
-		return math.ZeroUint(), nil
+		return math.ZeroInt(), nil
 	}
 
-	remainingUnbonding, err := k.deductUnbondingDelegation(ctx, delAddr, valAddr, remainingFromdel)
+	remainingUnbonding, err := k.deductUnbondingDelegation(ctx, delAddr, valAddr, remainingFromdel.TruncateInt())
 	if err != nil {
 		if errors.Is(err, stakingtypes.ErrNoUnbondingDelegation) {
-			return remainingFromdel, nil
+			return remainingFromdel.TruncateInt(), nil
 		}
-		return math.Uint{}, err
+		return math.Int{}, err
 	}
 	if remainingUnbonding.IsZero() {
-		return math.ZeroUint(), nil
+		return math.ZeroInt(), nil
 	}
 	return remainingUnbonding, nil
 }
diff --git a/x/reporter/types/message_create_reporter.go b/x/reporter/types/message_create_reporter.go
index e0f1ba32a..67c4e43cb 100644
--- a/x/reporter/types/message_create_reporter.go
+++ b/x/reporter/types/message_create_reporter.go
@@ -10,7 +10,7 @@ import (
 
 var _ sdk.Msg = &MsgCreateReporter{}
 
-func NewMsgCreateReporter(reporter string, commission math.Uint) *MsgCreateReporter {
+func NewMsgCreateReporter(reporter string, commission math.LegacyDec) *MsgCreateReporter {
 	return &MsgCreateReporter{
 		ReporterAddress: reporter,
 		CommissionRate:  commission,
diff --git a/x/reporter/types/msg_update_params_test.go b/x/reporter/types/msg_update_params_test.go
index c318d2e0e..0b3e8d954 100644
--- a/x/reporter/types/msg_update_params_test.go
+++ b/x/reporter/types/msg_update_params_test.go
@@ -28,7 +28,7 @@ func TestMsgUpdateParams_ValidateBasic(t *testing.T) {
 	msg = MsgUpdateParams{
 		Authority: sample.AccAddress(),
 		Params: Params{
-			MinCommissionRate: math.NewUint(5),
+			MinCommissionRate: math.LegacyNewDec(5),
 			MinTrb:            math.NewInt(1),
 			MaxSelectors:      100,
 		},
diff --git a/x/reporter/types/oracle_reporter.go b/x/reporter/types/oracle_reporter.go
index 67aa5ed84..5a9ba023e 100644
--- a/x/reporter/types/oracle_reporter.go
+++ b/x/reporter/types/oracle_reporter.go
@@ -4,7 +4,7 @@ import (
 	"cosmossdk.io/math"
 )
 
-func NewReporter(commission math.Uint, minTokensRequired math.Int) OracleReporter {
+func NewReporter(commission math.LegacyDec, minTokensRequired math.Int) OracleReporter {
 	return OracleReporter{
 		MinTokensRequired: minTokensRequired,
 		CommissionRate:    commission,
diff --git a/x/reporter/types/oracle_reporter.pb.go b/x/reporter/types/oracle_reporter.pb.go
index 6e875972a..aa736fc09 100644
--- a/x/reporter/types/oracle_reporter.pb.go
+++ b/x/reporter/types/oracle_reporter.pb.go
@@ -35,7 +35,7 @@ type OracleReporter struct {
 	// min_tokens_required to select this reporter
 	MinTokensRequired cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=min_tokens_required,json=minTokensRequired,proto3,customtype=cosmossdk.io/math.Int" json:"min_tokens_required"`
 	// commission for the reporter
-	CommissionRate cosmossdk_io_math.Uint `protobuf:"bytes,2,opt,name=commission_rate,json=commissionRate,proto3,customtype=cosmossdk.io/math.Uint" json:"commission_rate"`
+	CommissionRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=commission_rate,json=commissionRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"commission_rate"`
 	// jailed is a bool whether the reporter is jailed or not
 	Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"`
 	// jailed_until is the time the reporter is jailed until
@@ -89,46 +89,8 @@ func (m *OracleReporter) GetJailedUntil() time.Time {
 	return time.Time{}
 }
 
-type BigUint struct {
-	Value cosmossdk_io_math.Uint `protobuf:"bytes,1,opt,name=value,proto3,customtype=cosmossdk.io/math.Uint" json:"value"`
-}
-
-func (m *BigUint) Reset()         { *m = BigUint{} }
-func (m *BigUint) String() string { return proto.CompactTextString(m) }
-func (*BigUint) ProtoMessage()    {}
-func (*BigUint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_28310cb3dcf79802, []int{1}
-}
-func (m *BigUint) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *BigUint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_BigUint.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *BigUint) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BigUint.Merge(m, src)
-}
-func (m *BigUint) XXX_Size() int {
-	return m.Size()
-}
-func (m *BigUint) XXX_DiscardUnknown() {
-	xxx_messageInfo_BigUint.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BigUint proto.InternalMessageInfo
-
 func init() {
 	proto.RegisterType((*OracleReporter)(nil), "layer.reporter.OracleReporter")
-	proto.RegisterType((*BigUint)(nil), "layer.reporter.BigUint")
 }
 
 func init() {
@@ -136,33 +98,32 @@ func init() {
 }
 
 var fileDescriptor_28310cb3dcf79802 = []byte{
-	// 412 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xb1, 0x6e, 0xd4, 0x30,
-	0x18, 0xc7, 0xcf, 0x05, 0x0a, 0xf8, 0xe0, 0x50, 0x03, 0x54, 0xc7, 0x0d, 0xc9, 0xa9, 0x62, 0x38,
-	0x51, 0x9d, 0x2d, 0xc1, 0x1b, 0x04, 0x31, 0x54, 0x42, 0x20, 0x45, 0x2d, 0x03, 0x0c, 0x91, 0x2f,
-	0x67, 0x52, 0x53, 0xdb, 0x5f, 0xb0, 0x1d, 0x44, 0xdf, 0xa2, 0x8f, 0x81, 0xc4, 0xc2, 0xc0, 0x43,
-	0x74, 0xac, 0x98, 0x10, 0x43, 0x41, 0x77, 0x03, 0xaf, 0x81, 0x62, 0x3b, 0xba, 0x81, 0xa9, 0x4b,
-	0xe4, 0xff, 0x97, 0xef, 0xfb, 0xf9, 0xef, 0xbf, 0x3e, 0xfc, 0x58, 0xb2, 0x53, 0x6e, 0xa8, 0xe1,
-	0x0d, 0x18, 0xc7, 0x0d, 0x05, 0xc3, 0x2a, 0xc9, 0xcb, 0x5e, 0x93, 0xc6, 0x80, 0x83, 0x64, 0xe4,
-	0xbb, 0x48, 0x5f, 0x9d, 0xec, 0x30, 0x25, 0x34, 0x50, 0xff, 0x0d, 0x2d, 0x93, 0x47, 0x15, 0x58,
-	0x05, 0xb6, 0xf4, 0x8a, 0x06, 0x11, 0x7f, 0x3d, 0xa8, 0xa1, 0x86, 0x50, 0xef, 0x4e, 0xb1, 0x9a,
-	0xd5, 0x00, 0xb5, 0xe4, 0xd4, 0xab, 0x45, 0xfb, 0x9e, 0x3a, 0xa1, 0xb8, 0x75, 0x4c, 0x35, 0xa1,
-	0x61, 0xef, 0xeb, 0x16, 0x1e, 0xbd, 0xf6, 0x76, 0x8a, 0x78, 0x6f, 0xf2, 0x0e, 0xdf, 0x57, 0x42,
-	0x97, 0x0e, 0x4e, 0xb8, 0xb6, 0xa5, 0xe1, 0x1f, 0x5b, 0x61, 0xf8, 0x72, 0x8c, 0xa6, 0x68, 0x76,
-	0x3b, 0xdf, 0x3f, 0xbf, 0xcc, 0x06, 0xbf, 0x2e, 0xb3, 0x87, 0xe1, 0x72, 0xbb, 0x3c, 0x21, 0x02,
-	0xa8, 0x62, 0xee, 0x98, 0x1c, 0x68, 0xf7, 0xe3, 0xfb, 0x1c, 0x47, 0x57, 0x07, 0xda, 0x15, 0x3b,
-	0x4a, 0xe8, 0x43, 0x8f, 0x29, 0x22, 0x25, 0x79, 0x83, 0xef, 0x55, 0xa0, 0x94, 0xb0, 0x56, 0x80,
-	0x2e, 0x0d, 0x73, 0x7c, 0xbc, 0xe5, 0xc1, 0xf3, 0x08, 0xde, 0xfd, 0x1f, 0x7c, 0x24, 0x3c, 0x79,
-	0x18, 0xc9, 0x9d, 0x2c, 0x46, 0x1b, 0x4a, 0xc1, 0x1c, 0x4f, 0x76, 0xf1, 0xf6, 0x07, 0x26, 0x24,
-	0x5f, 0x8e, 0xaf, 0x4d, 0xd1, 0xec, 0x56, 0x11, 0x55, 0xf2, 0x12, 0xdf, 0x09, 0xa7, 0xb2, 0xd5,
-	0x4e, 0xc8, 0xf1, 0xf5, 0x29, 0x9a, 0x0d, 0x9f, 0x4e, 0x48, 0xc8, 0x85, 0xf4, 0xb9, 0x90, 0xc3,
-	0x3e, 0x97, 0xfc, 0x6e, 0x67, 0xe4, 0xec, 0x77, 0x86, 0xbe, 0xfc, 0xfd, 0xf6, 0x04, 0x15, 0xc3,
-	0x30, 0x7e, 0xd4, 0x4d, 0xef, 0xbd, 0xc2, 0x37, 0x73, 0x51, 0x77, 0x06, 0x92, 0xe7, 0xf8, 0xc6,
-	0x27, 0x26, 0x5b, 0x1e, 0x73, 0xb9, 0xa2, 0xfd, 0x30, 0x9b, 0xbf, 0x38, 0x5f, 0xa5, 0xe8, 0x62,
-	0x95, 0xa2, 0x3f, 0xab, 0x14, 0x9d, 0xad, 0xd3, 0xc1, 0xc5, 0x3a, 0x1d, 0xfc, 0x5c, 0xa7, 0x83,
-	0xb7, 0xfb, 0xb5, 0x70, 0xc7, 0xed, 0x82, 0x54, 0xa0, 0xa8, 0xe3, 0x52, 0x82, 0x99, 0x0b, 0xa0,
-	0x61, 0x8f, 0x3e, 0x6f, 0x36, 0xc9, 0x9d, 0x36, 0xdc, 0x2e, 0xb6, 0xfd, 0x33, 0x9e, 0xfd, 0x0b,
-	0x00, 0x00, 0xff, 0xff, 0xa5, 0x54, 0x18, 0x30, 0x68, 0x02, 0x00, 0x00,
+	// 397 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x92, 0xbf, 0x6e, 0x14, 0x31,
+	0x10, 0xc6, 0xd7, 0x01, 0x45, 0xb0, 0x81, 0x83, 0x2c, 0x7f, 0xb4, 0x1c, 0xd2, 0xee, 0x09, 0x51,
+	0x9c, 0x88, 0xce, 0x96, 0xa0, 0xa0, 0x3f, 0x41, 0x11, 0x29, 0x12, 0xd2, 0x2a, 0x34, 0x50, 0x2c,
+	0xbe, 0xbd, 0x61, 0x63, 0xb2, 0xf6, 0x2c, 0xb6, 0x57, 0xe2, 0xde, 0x22, 0x8f, 0x41, 0x49, 0x11,
+	0xde, 0x21, 0x65, 0x94, 0x0a, 0x51, 0x1c, 0xe8, 0xae, 0xe0, 0x35, 0xd0, 0xd9, 0x5e, 0xae, 0xa0,
+	0xb1, 0xe6, 0xfb, 0x3c, 0xf3, 0x9b, 0xd1, 0x68, 0xe2, 0xa7, 0x0d, 0x5f, 0x80, 0x66, 0x1a, 0x5a,
+	0xd4, 0x16, 0x34, 0x43, 0xcd, 0xab, 0x06, 0xca, 0x5e, 0xd3, 0x56, 0xa3, 0xc5, 0x64, 0xe0, 0xb2,
+	0x68, 0xef, 0x0e, 0xf7, 0xb9, 0x14, 0x0a, 0x99, 0x7b, 0x7d, 0xca, 0xf0, 0x51, 0x85, 0x46, 0xa2,
+	0x29, 0x9d, 0x62, 0x5e, 0x84, 0xaf, 0xfb, 0x35, 0xd6, 0xe8, 0xfd, 0x4d, 0x14, 0xdc, 0xbc, 0x46,
+	0xac, 0x1b, 0x60, 0x4e, 0xcd, 0xba, 0x8f, 0xcc, 0x0a, 0x09, 0xc6, 0x72, 0xd9, 0xfa, 0x84, 0x27,
+	0xdf, 0x77, 0xe2, 0xc1, 0x1b, 0x37, 0x4e, 0x11, 0xfa, 0x26, 0xef, 0xe3, 0x7b, 0x52, 0xa8, 0xd2,
+	0xe2, 0x29, 0x28, 0x53, 0x6a, 0xf8, 0xdc, 0x09, 0x0d, 0xf3, 0x94, 0x8c, 0xc8, 0xf8, 0xe6, 0xf4,
+	0xe0, 0x62, 0x99, 0x47, 0x3f, 0x97, 0xf9, 0x03, 0xdf, 0xdc, 0xcc, 0x4f, 0xa9, 0x40, 0x26, 0xb9,
+	0x3d, 0xa1, 0x87, 0xca, 0x5e, 0x9d, 0x4f, 0xe2, 0x30, 0xd5, 0xa1, 0xb2, 0xc5, 0xbe, 0x14, 0xea,
+	0xd8, 0x61, 0x8a, 0x40, 0x49, 0x3e, 0xc4, 0x77, 0x2a, 0x94, 0x52, 0x18, 0x23, 0x50, 0x95, 0x9a,
+	0x5b, 0x48, 0x77, 0x1c, 0xf8, 0x65, 0x00, 0x3f, 0xfe, 0x1f, 0x7c, 0x04, 0x35, 0xaf, 0x16, 0xaf,
+	0xa0, 0xba, 0x3a, 0x9f, 0xdc, 0x0d, 0xf8, 0x7f, 0x5e, 0x31, 0xd8, 0xf2, 0x0a, 0x6e, 0x21, 0x79,
+	0x18, 0xef, 0x7e, 0xe2, 0xa2, 0x81, 0x79, 0x7a, 0x6d, 0x44, 0xc6, 0x37, 0x8a, 0xa0, 0x92, 0xa3,
+	0xf8, 0x96, 0x8f, 0xca, 0x4e, 0x59, 0xd1, 0xa4, 0xd7, 0x47, 0x64, 0xbc, 0xf7, 0x7c, 0x48, 0xfd,
+	0x86, 0x68, 0xbf, 0x21, 0x7a, 0xdc, 0x6f, 0x68, 0x7a, 0x7b, 0x33, 0xd2, 0xd9, 0xaf, 0x9c, 0x7c,
+	0xfd, 0xf3, 0xed, 0x19, 0x29, 0xf6, 0x7c, 0xf9, 0xdb, 0x4d, 0xf5, 0xf4, 0xf5, 0xc5, 0x2a, 0x23,
+	0x97, 0xab, 0x8c, 0xfc, 0x5e, 0x65, 0xe4, 0x6c, 0x9d, 0x45, 0x97, 0xeb, 0x2c, 0xfa, 0xb1, 0xce,
+	0xa2, 0x77, 0x07, 0xb5, 0xb0, 0x27, 0xdd, 0x8c, 0x56, 0x28, 0x99, 0x85, 0xa6, 0x41, 0x3d, 0x11,
+	0xc8, 0xfc, 0x05, 0x7c, 0xd9, 0xde, 0x80, 0x5d, 0xb4, 0x60, 0x66, 0xbb, 0xae, 0xed, 0x8b, 0xbf,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x87, 0x19, 0x55, 0x22, 0x02, 0x00, 0x00,
 }
 
 func (m *OracleReporter) Marshal() (dAtA []byte, err error) {
@@ -226,39 +187,6 @@ func (m *OracleReporter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *BigUint) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *BigUint) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *BigUint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.Value.Size()
-		i -= size
-		if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintOracleReporter(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
 func encodeVarintOracleReporter(dAtA []byte, offset int, v uint64) int {
 	offset -= sovOracleReporter(v)
 	base := offset
@@ -288,17 +216,6 @@ func (m *OracleReporter) Size() (n int) {
 	return n
 }
 
-func (m *BigUint) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Value.Size()
-	n += 1 + l + sovOracleReporter(uint64(l))
-	return n
-}
-
 func sovOracleReporter(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -476,90 +393,6 @@ func (m *OracleReporter) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BigUint) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowOracleReporter
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: BigUint: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BigUint: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowOracleReporter
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthOracleReporter
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthOracleReporter
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipOracleReporter(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOracleReporter
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func skipOracleReporter(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/reporter/types/params.go b/x/reporter/types/params.go
index 1dc426ed2..dcbaeadf8 100644
--- a/x/reporter/types/params.go
+++ b/x/reporter/types/params.go
@@ -13,7 +13,7 @@ var _ paramtypes.ParamSet = (*Params)(nil)
 var (
 	KeyMinCommissionRate = []byte("MinCommissionRate")
 	// TODO: Determine the default value
-	DefaultMinCommissionRate = math.NewUint(0)
+	DefaultMinCommissionRate = math.LegacyZeroDec()
 	DefaultMinTrb            = math.NewIntWithDecimal(1, 6)
 	DefaultMaxSelectors      = uint64(100)
 )
@@ -25,7 +25,7 @@ func ParamKeyTable() paramtypes.KeyTable {
 
 // NewParams creates a new Params instance
 func NewParams(
-	minCommissionRate math.Uint,
+	minCommissionRate math.LegacyDec,
 	minTrb math.Int,
 ) Params {
 	return Params{
@@ -61,7 +61,7 @@ func (p Params) Validate() error {
 
 // validateMinStakeAmount validates the MinStakeAmount param
 func validateMinCommissionRate(v interface{}) error {
-	_, ok := v.(math.Uint)
+	_, ok := v.(math.LegacyDec)
 	if !ok {
 		return fmt.Errorf("invalid parameter type: %T", v)
 	}
diff --git a/x/reporter/types/params.pb.go b/x/reporter/types/params.pb.go
index 43f4be5b5..b687fd5b9 100644
--- a/x/reporter/types/params.pb.go
+++ b/x/reporter/types/params.pb.go
@@ -33,7 +33,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // Params defines the parameters for the module.
 type Params struct {
 	// min_commission_rate, adopted from staking module, is the minimum commission rate a reporter can their delegators
-	MinCommissionRate cosmossdk_io_math.Uint `protobuf:"bytes,1,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=cosmossdk.io/math.Uint" json:"min_commission_rate" yaml:"min_commission_rate"`
+	MinCommissionRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_commission_rate" yaml:"min_commission_rate"`
 	// min_trb to be a reporter
 	MinTrb cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=min_trb,json=minTrb,proto3,customtype=cosmossdk.io/math.Int" json:"min_trb" yaml:"min_trb"`
 	// max number of selectors for a reporter
@@ -133,36 +133,36 @@ func init() {
 func init() { proto.RegisterFile("layer/reporter/params.proto", fileDescriptor_2b46dabd827272cb) }
 
 var fileDescriptor_2b46dabd827272cb = []byte{
-	// 450 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0x3f, 0x8b, 0x13, 0x41,
-	0x18, 0xc6, 0x33, 0xe7, 0x11, 0x71, 0xee, 0x0f, 0xdc, 0xfa, 0x2f, 0x46, 0xd8, 0x0d, 0xb1, 0x39,
-	0x94, 0x9b, 0x01, 0xed, 0x0e, 0x05, 0x89, 0x58, 0x1c, 0x36, 0xb2, 0x17, 0x2d, 0x6c, 0xc2, 0xec,
-	0x3a, 0xee, 0x0d, 0xd9, 0x99, 0x77, 0x99, 0x79, 0x03, 0x09, 0x7e, 0x03, 0xab, 0xfb, 0x08, 0x16,
-	0x62, 0x6d, 0xe1, 0x87, 0xb8, 0xf2, 0xb0, 0x12, 0x8b, 0x28, 0x49, 0xa1, 0xb5, 0x9f, 0x40, 0x32,
-	0xb3, 0x31, 0x42, 0x84, 0x6b, 0x96, 0x7d, 0xdf, 0xf7, 0x79, 0xe7, 0x37, 0xcf, 0x33, 0xf4, 0x76,
-	0x29, 0x26, 0xd2, 0x72, 0x2b, 0x2b, 0xb0, 0x28, 0x2d, 0xaf, 0x84, 0x15, 0xda, 0xb1, 0xca, 0x02,
-	0x42, 0xb4, 0xeb, 0x87, 0x6c, 0x39, 0x6c, 0xef, 0x09, 0xad, 0x0c, 0x70, 0xff, 0x0d, 0x92, 0xf6,
-	0xad, 0x1c, 0x9c, 0x06, 0x37, 0xf0, 0x15, 0x0f, 0x45, 0x3d, 0xba, 0x56, 0x40, 0x01, 0xa1, 0xbf,
-	0xf8, 0xab, 0xbb, 0x49, 0x01, 0x50, 0x94, 0x92, 0xfb, 0x2a, 0x1b, 0xbd, 0xe1, 0xa8, 0xb4, 0x74,
-	0x28, 0x74, 0x15, 0x04, 0xdd, 0x0f, 0x1b, 0xb4, 0xf9, 0xdc, 0xdf, 0x22, 0x7a, 0x4b, 0xaf, 0x6a,
-	0x65, 0x06, 0x39, 0x68, 0xad, 0x9c, 0x53, 0x60, 0x06, 0x56, 0xa0, 0x6c, 0x91, 0x0e, 0xd9, 0xbf,
-	0xd2, 0x7b, 0x76, 0x36, 0x4d, 0x1a, 0xdf, 0xa6, 0xc9, 0x8d, 0x00, 0x75, 0xaf, 0x87, 0x4c, 0x01,
-	0xd7, 0x02, 0x4f, 0xd8, 0x0b, 0x65, 0xf0, 0xf7, 0x34, 0x69, 0x4f, 0x84, 0x2e, 0x0f, 0xbb, 0xff,
-	0x39, 0xa2, 0xfb, 0xe5, 0xf3, 0xc1, 0x56, 0x7d, 0xd9, 0x85, 0x38, 0xdd, 0xd3, 0xca, 0x3c, 0xf9,
-	0xab, 0x49, 0x05, 0xca, 0xe8, 0x25, 0xbd, 0xbc, 0xd8, 0x44, 0x9b, 0xb5, 0x36, 0x3c, 0xf0, 0x51,
-	0x0d, 0xbc, 0xbe, 0x0e, 0x3c, 0xf2, 0xbc, 0xdd, 0x15, 0x0f, 0x6d, 0xb6, 0x60, 0xd0, 0x9a, 0x71,
-	0x64, 0x30, 0x6d, 0x6a, 0x65, 0xfa, 0x36, 0x8b, 0xee, 0xd0, 0x1d, 0x2d, 0xc6, 0x03, 0x27, 0x4b,
-	0x99, 0x23, 0x58, 0xd7, 0xba, 0xd4, 0x21, 0xfb, 0x9b, 0xe9, 0xb6, 0x16, 0xe3, 0xe3, 0x65, 0xef,
-	0xb0, 0xf3, 0xeb, 0x7d, 0x42, 0xde, 0xfd, 0xfc, 0x74, 0xf7, 0x66, 0x78, 0x9f, 0xf1, 0xea, 0x85,
-	0x42, 0x36, 0xdd, 0x8f, 0x84, 0x6e, 0x1f, 0xa3, 0x18, 0xca, 0xbe, 0x15, 0xf9, 0x50, 0xda, 0xe8,
-	0x31, 0xa5, 0x72, 0x5c, 0x29, 0x2b, 0x50, 0x81, 0xf1, 0x19, 0x6d, 0xdd, 0x6f, 0xb3, 0x90, 0x36,
-	0x5b, 0xa6, 0xcd, 0xfa, 0xcb, 0xb4, 0x7b, 0x9b, 0xa7, 0xdf, 0x13, 0x92, 0xfe, 0xb3, 0x13, 0xf5,
-	0x69, 0x53, 0x68, 0x18, 0x19, 0xac, 0x0d, 0x3f, 0xbc, 0xc8, 0xf0, 0x4e, 0x30, 0x1c, 0x96, 0xd6,
-	0xfc, 0x86, 0x76, 0xef, 0xe9, 0xd9, 0x2c, 0x26, 0xe7, 0xb3, 0x98, 0xfc, 0x98, 0xc5, 0xe4, 0x74,
-	0x1e, 0x37, 0xce, 0xe7, 0x71, 0xe3, 0xeb, 0x3c, 0x6e, 0xbc, 0xba, 0x57, 0x28, 0x3c, 0x19, 0x65,
-	0x2c, 0x07, 0xcd, 0x51, 0x96, 0x25, 0xd8, 0x03, 0x05, 0x7c, 0xcd, 0x30, 0x4e, 0x2a, 0xe9, 0xb2,
-	0xa6, 0xb7, 0xf0, 0xe0, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2b, 0x99, 0x8f, 0xce, 0xb1, 0x02,
-	0x00, 0x00,
+	// 456 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x51, 0xb1, 0x6e, 0x13, 0x41,
+	0x10, 0xf5, 0x86, 0xc8, 0x88, 0x25, 0x89, 0xc8, 0x01, 0xc2, 0x38, 0xd2, 0x9d, 0x65, 0x9a, 0x08,
+	0x94, 0x5b, 0x09, 0xba, 0x08, 0x24, 0x64, 0xa0, 0x88, 0x44, 0x81, 0x2e, 0x86, 0x82, 0xc6, 0xda,
+	0x3b, 0x96, 0xcb, 0xca, 0x37, 0x3b, 0xa7, 0xdd, 0xb1, 0x64, 0x7f, 0x00, 0x0d, 0x55, 0x3e, 0x81,
+	0x8a, 0x16, 0x0a, 0x3e, 0x22, 0x65, 0x44, 0x85, 0x28, 0x0c, 0xb2, 0x0b, 0xa8, 0xf3, 0x05, 0xc8,
+	0xb7, 0xe7, 0x04, 0xc9, 0x48, 0x34, 0xa7, 0x9b, 0x37, 0xf3, 0xf6, 0xcd, 0x7b, 0xc3, 0x77, 0x0a,
+	0x39, 0x51, 0x56, 0x58, 0x55, 0xa2, 0x25, 0x65, 0x45, 0x29, 0xad, 0x04, 0x17, 0x97, 0x16, 0x09,
+	0x83, 0xad, 0xaa, 0x19, 0x2f, 0x9b, 0xed, 0x6d, 0x09, 0xda, 0xa0, 0xa8, 0xbe, 0x7e, 0xa4, 0x7d,
+	0x3b, 0x43, 0x07, 0xe8, 0x06, 0x55, 0x25, 0x7c, 0x51, 0xb7, 0x6e, 0xe4, 0x98, 0xa3, 0xc7, 0x17,
+	0x7f, 0x35, 0x1a, 0xe5, 0x88, 0x79, 0xa1, 0x44, 0x55, 0xa5, 0xa3, 0xb7, 0x82, 0x34, 0x28, 0x47,
+	0x12, 0x4a, 0x3f, 0xd0, 0xfd, 0xb4, 0xc6, 0x9b, 0x2f, 0xaa, 0x2d, 0x82, 0x77, 0x8c, 0x5f, 0x07,
+	0x6d, 0x06, 0x19, 0x02, 0x68, 0xe7, 0x34, 0x9a, 0x81, 0x95, 0xa4, 0x5a, 0xac, 0xc3, 0x76, 0xaf,
+	0xf4, 0x5e, 0x9e, 0x4c, 0xa3, 0xc6, 0xf7, 0x69, 0xb4, 0xe3, 0x55, 0xdd, 0x9b, 0x61, 0xac, 0x51,
+	0x80, 0xa4, 0xa3, 0xf8, 0xb9, 0xca, 0x65, 0x36, 0x79, 0xaa, 0xb2, 0xb3, 0x69, 0xd4, 0x9e, 0x48,
+	0x28, 0xf6, 0xbb, 0xff, 0x78, 0xa7, 0xfb, 0xf5, 0xcb, 0xde, 0xb5, 0x7a, 0xe5, 0x73, 0x46, 0xb2,
+	0x0d, 0xda, 0x3c, 0x39, 0x1f, 0x4c, 0x24, 0xa9, 0xe0, 0x15, 0xbf, 0xbc, 0xa0, 0x93, 0x4d, 0x5b,
+	0x6b, 0x95, 0xf4, 0xa3, 0x5a, 0xfa, 0xe6, 0xaa, 0xf4, 0x81, 0xa1, 0xb3, 0x69, 0xb4, 0x75, 0x21,
+	0x4a, 0x36, 0x5d, 0x08, 0xf1, 0x5a, 0xe8, 0xc0, 0x50, 0xd2, 0x04, 0x6d, 0xfa, 0x36, 0x0d, 0xee,
+	0xf0, 0x4d, 0x90, 0xe3, 0x81, 0x53, 0x85, 0xca, 0x08, 0xad, 0x6b, 0x5d, 0xea, 0xb0, 0xdd, 0xf5,
+	0x64, 0x03, 0xe4, 0xf8, 0x70, 0x89, 0xed, 0x77, 0x7e, 0x7f, 0x88, 0xd8, 0xfb, 0x5f, 0x9f, 0xef,
+	0xde, 0xf2, 0xa7, 0x1a, 0x5f, 0x1c, 0xcb, 0xc7, 0xd4, 0xfd, 0xc8, 0xf8, 0xc6, 0x21, 0xc9, 0xa1,
+	0xea, 0x5b, 0x99, 0x0d, 0x95, 0x0d, 0x1e, 0x73, 0xae, 0xc6, 0xa5, 0xb6, 0x92, 0x34, 0x9a, 0x2a,
+	0xad, 0xab, 0xf7, 0xdb, 0xb1, 0x0f, 0x3e, 0x5e, 0x06, 0x1f, 0xf7, 0x97, 0xc1, 0xf7, 0xd6, 0x8f,
+	0x7f, 0x44, 0x2c, 0xf9, 0x8b, 0x13, 0xf4, 0x79, 0x53, 0x02, 0x8e, 0x0c, 0xd5, 0x86, 0x1f, 0xfe,
+	0xcf, 0xf0, 0xa6, 0x37, 0xec, 0x49, 0x2b, 0x7e, 0x3d, 0xdc, 0x7b, 0x76, 0x32, 0x0b, 0xd9, 0xe9,
+	0x2c, 0x64, 0x3f, 0x67, 0x21, 0x3b, 0x9e, 0x87, 0x8d, 0xd3, 0x79, 0xd8, 0xf8, 0x36, 0x0f, 0x1b,
+	0xaf, 0xef, 0xe5, 0x9a, 0x8e, 0x46, 0x69, 0x9c, 0x21, 0x08, 0x52, 0x45, 0x81, 0x76, 0x4f, 0xa3,
+	0x58, 0x31, 0x4c, 0x93, 0x52, 0xb9, 0xb4, 0x59, 0x59, 0x78, 0xf0, 0x27, 0x00, 0x00, 0xff, 0xff,
+	0x7d, 0xa3, 0x3f, 0xf9, 0xbc, 0x02, 0x00, 0x00,
 }
 
 func (this *Params) Equal(that interface{}) bool {
diff --git a/x/reporter/types/params_test.go b/x/reporter/types/params_test.go
index c794ae5a4..504abb961 100644
--- a/x/reporter/types/params_test.go
+++ b/x/reporter/types/params_test.go
@@ -14,24 +14,24 @@ import (
 func TestParams_NewParams(t *testing.T) {
 	require := require.New(t)
 
-	params := NewParams(math.NewUint(5), math.NewInt(1))
+	params := NewParams(math.LegacyNewDec(5), math.NewInt(1))
 	require.NoError(params.Validate())
-	require.Equal(params.MinCommissionRate, math.NewUint(5))
+	require.Equal(params.MinCommissionRate, math.LegacyNewDec(5))
 	require.Equal(params.MinTrb, math.NewInt(1))
 
-	params = NewParams(math.NewUint(0), math.NewInt(0))
+	params = NewParams(math.LegacyZeroDec(), math.NewInt(0))
 	require.NoError(params.Validate())
-	require.Equal(params.MinCommissionRate, math.ZeroUint())
+	require.Equal(params.MinCommissionRate, math.LegacyZeroDec())
 	require.Equal(params.MinTrb, math.NewInt(0))
 
-	params = NewParams(math.NewUint(100), math.NewInt(100))
+	params = NewParams(math.LegacyNewDec(100), math.NewInt(100))
 	require.NoError(params.Validate())
-	require.Equal(params.MinCommissionRate, math.NewUint(100))
+	require.Equal(params.MinCommissionRate, math.LegacyNewDec(100))
 	require.Equal(params.MinTrb, math.NewInt(100))
 
-	params = NewParams(math.NewUint(100), math.NewInt(1000))
+	params = NewParams(math.LegacyNewDec(100), math.NewInt(1000))
 	require.NoError(params.Validate())
-	require.Equal(params.MinCommissionRate, math.NewUint(100))
+	require.Equal(params.MinCommissionRate, math.LegacyNewDec(100))
 	require.Equal(params.MinTrb, math.NewInt(1000))
 }
 
diff --git a/x/reporter/types/query.pb.go b/x/reporter/types/query.pb.go
index 0bc45c2b0..7583111e9 100644
--- a/x/reporter/types/query.pb.go
+++ b/x/reporter/types/query.pb.go
@@ -733,7 +733,7 @@ func (m *QueryAvailableTipsRequest) GetSelectorAddress() string {
 
 type QueryAvailableTipsResponse struct {
 	// available_tips defines the tips available for withdrawal for a given selector.
-	AvailableTips cosmossdk_io_math.Uint `protobuf:"bytes,1,opt,name=available_tips,json=availableTips,proto3,customtype=cosmossdk.io/math.Uint" json:"available_tips"`
+	AvailableTips cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=available_tips,json=availableTips,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"available_tips"`
 }
 
 func (m *QueryAvailableTipsResponse) Reset()         { *m = QueryAvailableTipsResponse{} }
@@ -792,74 +792,74 @@ func init() {
 func init() { proto.RegisterFile("layer/reporter/query.proto", fileDescriptor_a043abc58a7b99a9) }
 
 var fileDescriptor_a043abc58a7b99a9 = []byte{
-	// 1062 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x6f, 0xdc, 0x44,
-	0x1c, 0x5d, 0x07, 0x1a, 0x92, 0x89, 0xf2, 0xc1, 0x90, 0x86, 0xad, 0x5b, 0x36, 0x95, 0xd3, 0xb4,
-	0x4b, 0x82, 0x6d, 0x9a, 0xb4, 0x48, 0xb4, 0x02, 0x91, 0x54, 0x0d, 0x04, 0x24, 0xba, 0x71, 0x5a,
-	0x0e, 0x5c, 0x96, 0xd9, 0xdd, 0x89, 0x6b, 0xd5, 0xf6, 0xb8, 0xf6, 0xb8, 0x74, 0xa9, 0x7a, 0xe1,
-	0x02, 0x27, 0x84, 0xc4, 0x05, 0x6e, 0x3d, 0x22, 0x71, 0xe1, 0x50, 0x89, 0x33, 0xb7, 0x1c, 0xab,
-	0x72, 0x81, 0x1e, 0x2a, 0x94, 0x20, 0xc1, 0x9f, 0x81, 0x3c, 0x1f, 0xde, 0x5d, 0xaf, 0x1d, 0x6f,
-	0x24, 0xb8, 0x44, 0xeb, 0xf9, 0x7d, 0xbc, 0xf7, 0x7e, 0xfe, 0xcd, 0xb3, 0x02, 0x54, 0x17, 0x75,
-	0x71, 0x68, 0x86, 0x38, 0x20, 0x21, 0xc5, 0xa1, 0x79, 0x37, 0xc6, 0x61, 0xd7, 0x08, 0x42, 0x42,
-	0x09, 0x9c, 0x61, 0x31, 0x43, 0xc6, 0xd4, 0x97, 0x91, 0xe7, 0xf8, 0xc4, 0x64, 0x7f, 0x79, 0x8a,
-	0xba, 0xd2, 0x26, 0x91, 0x47, 0x22, 0xb3, 0x85, 0x22, 0xcc, 0x6b, 0xcd, 0x7b, 0x17, 0x5b, 0x98,
-	0xa2, 0x8b, 0x66, 0x80, 0x6c, 0xc7, 0x47, 0xd4, 0x21, 0xbe, 0xc8, 0xad, 0xf5, 0xe7, 0xca, 0xac,
-	0x36, 0x71, 0x64, 0xfc, 0x14, 0x8f, 0x37, 0xd9, 0x93, 0xc9, 0x1f, 0x44, 0x68, 0xde, 0x26, 0x36,
-	0xe1, 0xe7, 0xc9, 0x2f, 0x71, 0x7a, 0xc6, 0x26, 0xc4, 0x76, 0xb1, 0x89, 0x02, 0xc7, 0x44, 0xbe,
-	0x4f, 0x28, 0x43, 0x93, 0x35, 0xe7, 0x32, 0xca, 0x48, 0x88, 0xda, 0x2e, 0x6e, 0xca, 0x67, 0x91,
-	0x75, 0x3a, 0x93, 0x15, 0xa0, 0x10, 0x79, 0xa2, 0x85, 0x36, 0x0f, 0xe0, 0x4e, 0xa2, 0xa9, 0xc1,
-	0x0e, 0x2d, 0x7c, 0x37, 0xc6, 0x11, 0xd5, 0x1a, 0xe0, 0x95, 0x81, 0xd3, 0x28, 0x20, 0x7e, 0x84,
-	0xe1, 0xdb, 0x60, 0x9c, 0x17, 0x57, 0x95, 0xb3, 0x4a, 0x7d, 0x6a, 0x6d, 0xc1, 0x18, 0x1c, 0x9f,
-	0xc1, 0xf3, 0x37, 0x27, 0xf7, 0x9f, 0x2f, 0x56, 0x7e, 0xfc, 0xfb, 0xe7, 0x15, 0xc5, 0x12, 0x05,
-	0x5a, 0x13, 0x9c, 0x64, 0x1d, 0x2d, 0x91, 0x2a, 0xa1, 0xe0, 0x16, 0x00, 0xbd, 0x31, 0x8a, 0xbe,
-	0xe7, 0x0d, 0x31, 0x9a, 0x64, 0x8e, 0x06, 0x7f, 0x5f, 0x62, 0x9a, 0x46, 0x03, 0xd9, 0x58, 0xd4,
-	0x5a, 0x7d, 0x95, 0xda, 0x17, 0x60, 0x42, 0xd2, 0x80, 0x6b, 0xe0, 0x25, 0xd4, 0xe9, 0x84, 0x38,
-	0xe2, 0x44, 0x27, 0x37, 0xab, 0x4f, 0x1f, 0xeb, 0xf3, 0xa2, 0xe7, 0x06, 0x8f, 0xec, 0xd2, 0xd0,
-	0xf1, 0x6d, 0x4b, 0x26, 0xc2, 0x2b, 0x60, 0xc2, 0xc3, 0x14, 0x75, 0x10, 0x45, 0xd5, 0x31, 0xc6,
-	0xa2, 0x96, 0x55, 0x77, 0x83, 0x8d, 0x57, 0x2a, 0xb0, 0xd2, 0x7c, 0xed, 0x07, 0x05, 0x2c, 0x64,
-	0xd5, 0x89, 0x91, 0xbd, 0x05, 0x26, 0x65, 0x7d, 0x42, 0xe6, 0x85, 0xfa, 0xd4, 0x5a, 0x35, 0xdb,
-	0x57, 0xfe, 0xb0, 0x7a, 0xa9, 0xf0, 0xfd, 0x81, 0xb1, 0x70, 0x42, 0x17, 0x4a, 0xc7, 0xc2, 0x41,
-	0x07, 0xe6, 0xe2, 0x81, 0x33, 0x8c, 0xda, 0x2e, 0x76, 0x71, 0x9b, 0x92, 0x30, 0xa5, 0x2f, 0xe6,
-	0x7f, 0x0d, 0xcc, 0x45, 0x22, 0xd4, 0x1c, 0x75, 0x68, 0xb3, 0xb2, 0x42, 0x1c, 0x5f, 0x99, 0xf8,
-	0xfa, 0xd1, 0x62, 0xe5, 0x9f, 0x47, 0x8b, 0x15, 0xed, 0x16, 0x78, 0xad, 0x00, 0x4e, 0x0c, 0xe4,
-	0x52, 0xef, 0x3d, 0x95, 0xe2, 0xa4, 0x99, 0xda, 0x69, 0x70, 0x8a, 0xb5, 0xdd, 0x70, 0x5d, 0xf2,
-	0x39, 0xee, 0x6c, 0x78, 0x24, 0xf6, 0xa9, 0xdc, 0xd6, 0x7d, 0x05, 0xa8, 0x79, 0x51, 0x81, 0x68,
-	0x81, 0x99, 0x88, 0xa2, 0x3b, 0x8e, 0x6f, 0x37, 0x11, 0x8b, 0x08, 0xdc, 0xd5, 0x64, 0x4b, 0x9f,
-	0x3d, 0x5f, 0x3c, 0xc9, 0xb1, 0xa3, 0xce, 0x1d, 0xc3, 0x21, 0xa6, 0x87, 0xe8, 0x6d, 0x63, 0xdb,
-	0xa7, 0x4f, 0x1f, 0xeb, 0x40, 0x90, 0xda, 0xf6, 0xa9, 0x35, 0x2d, 0x5a, 0xf0, 0xde, 0xf0, 0x13,
-	0x30, 0x17, 0xfb, 0x99, 0xae, 0x63, 0xc7, 0xef, 0x3a, 0x9b, 0x36, 0xe1, 0x7d, 0xb5, 0x65, 0xb0,
-	0x34, 0xac, 0xe4, 0xfa, 0xfd, 0xc0, 0x09, 0xd9, 0xdb, 0x94, 0x8a, 0xb7, 0xc0, 0xb9, 0xa3, 0xd3,
-	0x84, 0xf4, 0x1a, 0x00, 0x38, 0x3d, 0x65, 0xb2, 0x5f, 0xb4, 0xfa, 0x4e, 0xb4, 0x58, 0xf4, 0xf9,
-	0x38, 0xf6, 0x6e, 0xec, 0xc9, 0x57, 0x16, 0x6d, 0x76, 0x73, 0x96, 0x44, 0xbe, 0x8a, 0xd1, 0x97,
-	0x44, 0x56, 0x0c, 0x2f, 0xc9, 0x0e, 0x58, 0x2e, 0x81, 0x15, 0xfc, 0xeb, 0x60, 0xce, 0x8f, 0xbd,
-	0x26, 0xd9, 0x6b, 0xca, 0x8d, 0xe3, 0xb8, 0x27, 0xac, 0x19, 0x7f, 0xa0, 0x36, 0x55, 0xb2, 0x1b,
-	0xa0, 0x36, 0xde, 0xb8, 0x87, 0x1c, 0x17, 0xb5, 0x5c, 0xfc, 0xbf, 0x2b, 0x69, 0x08, 0x25, 0xc5,
-	0xb0, 0x42, 0xc9, 0x05, 0x30, 0x1b, 0x25, 0x39, 0x4d, 0x24, 0x93, 0xa4, 0x90, 0x68, 0xa0, 0x54,
-	0xfb, 0x4c, 0x6e, 0xba, 0x3c, 0xb9, 0xe9, 0x04, 0xd1, 0x7f, 0x79, 0x59, 0xb5, 0x50, 0xde, 0x96,
-	0x41, 0x04, 0x41, 0xf4, 0x26, 0x98, 0x49, 0x29, 0x36, 0xa9, 0x13, 0x48, 0x00, 0x5d, 0xec, 0xf5,
-	0xc2, 0xf0, 0x5e, 0xdf, 0x72, 0xd8, 0x62, 0x4f, 0x09, 0xf8, 0xe4, 0xd1, 0x9a, 0x46, 0xfd, 0xdd,
-	0xd7, 0xbe, 0x99, 0x02, 0x27, 0x18, 0x28, 0x7c, 0x00, 0xc6, 0xf9, 0x57, 0x02, 0x6a, 0x59, 0x1f,
-	0x1c, 0xfe, 0x10, 0xa9, 0x4b, 0x47, 0xe6, 0x70, 0xca, 0x5a, 0xfd, 0xcb, 0xdf, 0xfe, 0xfa, 0x6e,
-	0x4c, 0x83, 0x67, 0x4d, 0x8a, 0x5d, 0x97, 0x84, 0xba, 0x43, 0xcc, 0xdc, 0x6f, 0x1e, 0xfc, 0x4a,
-	0x01, 0x93, 0xa9, 0x47, 0xc3, 0xe5, 0xdc, 0xe6, 0xd9, 0x2f, 0x94, 0x7a, 0xbe, 0x2c, 0x4d, 0xd0,
-	0x58, 0x65, 0x34, 0x96, 0xe1, 0x52, 0x31, 0x8d, 0x9e, 0xbf, 0xff, 0xa2, 0x80, 0xb9, 0xac, 0x47,
-	0xc2, 0x37, 0x72, 0x91, 0x0a, 0x9c, 0x5b, 0xd5, 0x47, 0xcc, 0x16, 0xf4, 0xb6, 0x18, 0xbd, 0xf7,
-	0xe0, 0xbb, 0xc5, 0xf4, 0xe4, 0xa6, 0xe8, 0xe9, 0xc9, 0x83, 0xec, 0xba, 0x3d, 0x84, 0xdf, 0x2b,
-	0x60, 0x7a, 0xc0, 0x77, 0xe0, 0xeb, 0xb9, 0x44, 0xf2, 0xac, 0x5a, 0x5d, 0x19, 0x25, 0x55, 0x10,
-	0x7e, 0x93, 0x11, 0x5e, 0x81, 0xf5, 0x62, 0xc2, 0x88, 0x17, 0xea, 0xdc, 0x81, 0xe1, 0xaf, 0x0a,
-	0x78, 0xb5, 0xc0, 0x12, 0xe1, 0x7a, 0x39, 0xf2, 0x90, 0xcf, 0xaa, 0x97, 0x8e, 0x57, 0x24, 0x88,
-	0x5f, 0x65, 0xc4, 0x2f, 0xc3, 0xf5, 0x51, 0x89, 0xeb, 0x3d, 0x4b, 0x86, 0xcf, 0x14, 0x50, 0x2d,
-	0xf2, 0x45, 0x98, 0xcf, 0xa7, 0xc4, 0xbd, 0xd5, 0xcb, 0xc7, 0xac, 0x12, 0x32, 0x76, 0x98, 0x8c,
-	0x8f, 0xe0, 0x76, 0xb1, 0x0c, 0x3f, 0xf6, 0x74, 0xb2, 0xa7, 0xa7, 0xe6, 0xac, 0xb7, 0xba, 0x7d,
-	0xbb, 0x93, 0x35, 0xda, 0x87, 0xf0, 0x0f, 0x05, 0x54, 0x8b, 0xac, 0xb2, 0x40, 0x5c, 0x89, 0xa1,
-	0x17, 0x88, 0x2b, 0xf3, 0x63, 0xad, 0xc1, 0xc4, 0x7d, 0x08, 0x3f, 0x38, 0xe2, 0x36, 0x24, 0x3d,
-	0xf4, 0xd4, 0xc7, 0xca, 0xb4, 0xfd, 0x94, 0xdc, 0x8b, 0x7e, 0xd3, 0x2b, 0xba, 0x17, 0x39, 0xc6,
-	0x5e, 0x74, 0x2f, 0xf2, 0x1c, 0x5a, 0xbb, 0xc6, 0xa8, 0xbf, 0x03, 0xaf, 0x1e, 0xb1, 0x5e, 0x29,
-	0xe9, 0xc4, 0xc1, 0x73, 0x6e, 0xf1, 0xe6, 0xf5, 0xfd, 0x83, 0x9a, 0xf2, 0xe4, 0xa0, 0xa6, 0xfc,
-	0x79, 0x50, 0x53, 0xbe, 0x3d, 0xac, 0x55, 0x9e, 0x1c, 0xd6, 0x2a, 0xbf, 0x1f, 0xd6, 0x2a, 0x9f,
-	0xae, 0xda, 0x0e, 0xbd, 0x1d, 0xb7, 0x8c, 0x36, 0xf1, 0x86, 0x00, 0xee, 0xf7, 0x20, 0x68, 0x37,
-	0xc0, 0x51, 0x6b, 0x9c, 0xfd, 0x17, 0xb1, 0xfe, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x97, 0x43,
-	0xdb, 0xd8, 0x64, 0x0d, 0x00, 0x00,
+	// 1070 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcf, 0x6f, 0xdc, 0x44,
+	0x14, 0x5e, 0x07, 0x1a, 0x92, 0x89, 0xf2, 0x83, 0x21, 0x2d, 0x5b, 0xa7, 0x6c, 0x2a, 0xa7, 0x69,
+	0x97, 0x04, 0xdb, 0x34, 0x69, 0x41, 0xb4, 0x02, 0x91, 0x94, 0x06, 0x02, 0x88, 0x6e, 0x1c, 0xe0,
+	0xc0, 0x81, 0x65, 0x76, 0x77, 0xe2, 0x5a, 0xb5, 0x3d, 0xae, 0x3d, 0x5b, 0xba, 0x94, 0x5e, 0xb8,
+	0xc0, 0x09, 0x21, 0x71, 0x81, 0x5b, 0x8f, 0x48, 0x5c, 0x38, 0x44, 0xe2, 0xcc, 0x2d, 0xc7, 0x2a,
+	0x5c, 0xa0, 0x87, 0x0a, 0x25, 0x48, 0xf0, 0x67, 0x20, 0xcf, 0x0f, 0xef, 0xae, 0xd7, 0x8e, 0x37,
+	0x12, 0xbd, 0x44, 0xeb, 0x37, 0xef, 0xbd, 0xef, 0xfb, 0x9e, 0xdf, 0x7c, 0x56, 0x80, 0xea, 0xa2,
+	0x0e, 0x0e, 0xcd, 0x10, 0x07, 0x24, 0xa4, 0x38, 0x34, 0x6f, 0xb7, 0x71, 0xd8, 0x31, 0x82, 0x90,
+	0x50, 0x02, 0xa7, 0xd8, 0x99, 0x21, 0xcf, 0xd4, 0x67, 0x91, 0xe7, 0xf8, 0xc4, 0x64, 0x7f, 0x79,
+	0x8a, 0xba, 0xd4, 0x24, 0x91, 0x47, 0x22, 0xb3, 0x81, 0x22, 0xcc, 0x6b, 0xcd, 0x3b, 0x17, 0x1b,
+	0x98, 0xa2, 0x8b, 0x66, 0x80, 0x6c, 0xc7, 0x47, 0xd4, 0x21, 0xbe, 0xc8, 0xad, 0xf4, 0xe6, 0xca,
+	0xac, 0x26, 0x71, 0xe4, 0xf9, 0x69, 0x7e, 0x5e, 0x67, 0x4f, 0x26, 0x7f, 0x10, 0x47, 0xb3, 0x36,
+	0xb1, 0x09, 0x8f, 0xc7, 0xbf, 0x44, 0xf4, 0x8c, 0x4d, 0x88, 0xed, 0x62, 0x13, 0x05, 0x8e, 0x89,
+	0x7c, 0x9f, 0x50, 0x86, 0x26, 0x6b, 0xce, 0xa5, 0x94, 0x91, 0x10, 0x35, 0x5d, 0x5c, 0x97, 0xcf,
+	0x22, 0x6b, 0x2e, 0x95, 0x15, 0xa0, 0x10, 0x79, 0xa2, 0x85, 0x36, 0x0b, 0xe0, 0x56, 0xac, 0xa9,
+	0xc6, 0x82, 0x16, 0xbe, 0xdd, 0xc6, 0x11, 0xd5, 0x6a, 0xe0, 0xb9, 0xbe, 0x68, 0x14, 0x10, 0x3f,
+	0xc2, 0xf0, 0x35, 0x30, 0xca, 0x8b, 0xcb, 0xca, 0x59, 0xa5, 0x3a, 0xb1, 0x72, 0xca, 0xe8, 0x1f,
+	0x9f, 0xc1, 0xf3, 0xd7, 0xc7, 0xf7, 0x1e, 0xcf, 0x97, 0x7e, 0xfa, 0xe7, 0x97, 0x25, 0xc5, 0x12,
+	0x05, 0x5a, 0x1d, 0x9c, 0x64, 0x1d, 0x2d, 0x91, 0x2a, 0xa1, 0xe0, 0x06, 0x00, 0xdd, 0x31, 0x8a,
+	0xbe, 0xe7, 0x0d, 0x31, 0x9a, 0x78, 0x8e, 0x06, 0x7f, 0x5f, 0x62, 0x9a, 0x46, 0x0d, 0xd9, 0x58,
+	0xd4, 0x5a, 0x3d, 0x95, 0xda, 0x17, 0x60, 0x4c, 0xd2, 0x80, 0x2b, 0xe0, 0x19, 0xd4, 0x6a, 0x85,
+	0x38, 0xe2, 0x44, 0xc7, 0xd7, 0xcb, 0xfb, 0xbb, 0xfa, 0xac, 0xe8, 0xb9, 0xc6, 0x4f, 0xb6, 0x69,
+	0xe8, 0xf8, 0xb6, 0x25, 0x13, 0xe1, 0x15, 0x30, 0xe6, 0x61, 0x8a, 0x5a, 0x88, 0xa2, 0xf2, 0x08,
+	0x63, 0x51, 0x49, 0xab, 0xbb, 0xc1, 0xc6, 0x2b, 0x15, 0x58, 0x49, 0xbe, 0xf6, 0xa3, 0x02, 0x4e,
+	0xa5, 0xd5, 0x89, 0x91, 0xbd, 0x02, 0xc6, 0x65, 0x7d, 0x4c, 0xe6, 0xa9, 0xea, 0xc4, 0x4a, 0x39,
+	0xdd, 0x57, 0xfe, 0xb0, 0xba, 0xa9, 0xf0, 0xed, 0xbe, 0xb1, 0x70, 0x42, 0x17, 0x0a, 0xc7, 0xc2,
+	0x41, 0xfb, 0xe6, 0xe2, 0x81, 0x33, 0x8c, 0xda, 0x36, 0x76, 0x71, 0x93, 0x92, 0x30, 0xa1, 0x2f,
+	0xe6, 0x7f, 0x0d, 0xcc, 0x44, 0xe2, 0xa8, 0x3e, 0xec, 0xd0, 0xa6, 0x65, 0x85, 0x08, 0x5f, 0x19,
+	0xfb, 0xe6, 0xc1, 0x7c, 0xe9, 0xdf, 0x07, 0xf3, 0x25, 0xed, 0x23, 0xf0, 0x42, 0x0e, 0x9c, 0x18,
+	0xc8, 0xa5, 0xee, 0x7b, 0x2a, 0xc4, 0x49, 0x32, 0xb5, 0x39, 0x70, 0x9a, 0xb5, 0x5d, 0x73, 0x5d,
+	0xf2, 0x39, 0x6e, 0xad, 0x79, 0xa4, 0xed, 0x53, 0xb9, 0xad, 0x7b, 0x0a, 0x50, 0xb3, 0x4e, 0x05,
+	0xa2, 0x05, 0xa6, 0x22, 0x8a, 0x6e, 0x39, 0xbe, 0x5d, 0x47, 0xec, 0x44, 0xe0, 0x2e, 0xc7, 0x5b,
+	0xfa, 0xe8, 0xf1, 0xfc, 0x49, 0x8e, 0x1d, 0xb5, 0x6e, 0x19, 0x0e, 0x31, 0x3d, 0x44, 0x6f, 0x1a,
+	0x9b, 0x3e, 0xdd, 0xdf, 0xd5, 0x81, 0x20, 0xb5, 0xe9, 0x53, 0x6b, 0x52, 0xb4, 0xe0, 0xbd, 0xe1,
+	0xc7, 0x60, 0xa6, 0xed, 0xa7, 0xba, 0x8e, 0x1c, 0xbf, 0xeb, 0x74, 0xd2, 0x84, 0xf7, 0xd5, 0x16,
+	0xc1, 0xc2, 0xa0, 0x92, 0xeb, 0x77, 0x03, 0x27, 0x64, 0x6f, 0x53, 0x2a, 0xde, 0x00, 0xe7, 0x8e,
+	0x4e, 0x13, 0xd2, 0x2b, 0x00, 0xe0, 0x24, 0xca, 0x64, 0x3f, 0x6d, 0xf5, 0x44, 0xb4, 0xb6, 0xe8,
+	0xf3, 0x41, 0xdb, 0xbb, 0xb1, 0x23, 0x5f, 0x59, 0xb4, 0xde, 0xc9, 0x58, 0x12, 0xf9, 0x2a, 0x86,
+	0x5f, 0x12, 0x59, 0x31, 0xb8, 0x24, 0x5b, 0x60, 0xb1, 0x00, 0x56, 0xf0, 0xaf, 0x82, 0x19, 0xbf,
+	0xed, 0xd5, 0xc9, 0x4e, 0x5d, 0x6e, 0x1c, 0xc7, 0x3d, 0x61, 0x4d, 0xf9, 0x7d, 0xb5, 0x89, 0x92,
+	0xed, 0x00, 0x35, 0xf1, 0xda, 0x1d, 0xe4, 0xb8, 0xa8, 0xe1, 0xe2, 0x27, 0xae, 0xa4, 0x26, 0x94,
+	0xe4, 0xc3, 0x0a, 0x25, 0x17, 0xc0, 0x74, 0x14, 0xe7, 0xd4, 0x91, 0x4c, 0x92, 0x42, 0xa2, 0xbe,
+	0x52, 0xed, 0x33, 0xb9, 0xe9, 0x32, 0xf2, 0xa1, 0x13, 0x44, 0xff, 0xe7, 0x65, 0xd5, 0xbe, 0x94,
+	0xb7, 0xa5, 0x1f, 0x41, 0x10, 0xfd, 0x14, 0x4c, 0x25, 0x14, 0xeb, 0xd4, 0x09, 0x24, 0xc0, 0xab,
+	0x62, 0xaf, 0xe7, 0x06, 0xf7, 0xfa, 0x7d, 0x6c, 0xa3, 0x66, 0xe7, 0x2d, 0xdc, 0xdc, 0xdf, 0xd5,
+	0x67, 0x04, 0x87, 0x24, 0x66, 0x4d, 0xa2, 0x5e, 0x9c, 0x95, 0x6f, 0x27, 0xc0, 0x09, 0x06, 0x0f,
+	0xef, 0x81, 0x51, 0xfe, 0xbd, 0x80, 0x5a, 0xda, 0x11, 0x07, 0x3f, 0x49, 0xea, 0xc2, 0x91, 0x39,
+	0x9c, 0xbc, 0x56, 0xfd, 0xea, 0xf7, 0xbf, 0xbf, 0x1f, 0xd1, 0xe0, 0x59, 0x93, 0x62, 0xd7, 0x25,
+	0xa1, 0xee, 0x10, 0x33, 0xf3, 0xeb, 0x07, 0xbf, 0x56, 0xc0, 0x78, 0xe2, 0xd6, 0x70, 0x31, 0xb3,
+	0x79, 0xfa, 0x5b, 0xa5, 0x9e, 0x2f, 0x4a, 0x13, 0x34, 0x96, 0x19, 0x8d, 0x45, 0xb8, 0x90, 0x4f,
+	0xa3, 0xeb, 0xf4, 0xbf, 0x2a, 0x60, 0x26, 0xed, 0x96, 0xf0, 0xa5, 0x4c, 0xa4, 0x1c, 0x0f, 0x57,
+	0xf5, 0x21, 0xb3, 0x05, 0xbd, 0x0d, 0x46, 0xef, 0x4d, 0xf8, 0x46, 0x3e, 0x3d, 0xb9, 0x33, 0x7a,
+	0x12, 0xb9, 0x97, 0x5e, 0xbc, 0xfb, 0xf0, 0x07, 0x05, 0x4c, 0xf6, 0x39, 0x10, 0x7c, 0x31, 0x93,
+	0x48, 0x96, 0x69, 0xab, 0x4b, 0xc3, 0xa4, 0x0a, 0xc2, 0x2f, 0x33, 0xc2, 0x4b, 0xb0, 0x9a, 0x4f,
+	0x18, 0xf1, 0x42, 0x9d, 0x7b, 0x31, 0xfc, 0x4d, 0x01, 0xcf, 0xe7, 0x98, 0x23, 0x5c, 0x2d, 0x46,
+	0x1e, 0x70, 0x5c, 0xf5, 0xd2, 0xf1, 0x8a, 0x04, 0xf1, 0xab, 0x8c, 0xf8, 0x65, 0xb8, 0x3a, 0x2c,
+	0x71, 0xbd, 0x6b, 0xce, 0xf0, 0x91, 0x02, 0xca, 0x79, 0x0e, 0x09, 0xb3, 0xf9, 0x14, 0xf8, 0xb8,
+	0x7a, 0xf9, 0x98, 0x55, 0x42, 0xc6, 0x16, 0x93, 0xf1, 0x1e, 0xdc, 0xcc, 0x97, 0xe1, 0xb7, 0x3d,
+	0x9d, 0xec, 0xe8, 0x89, 0x4d, 0xeb, 0x8d, 0x4e, 0xcf, 0xee, 0xa4, 0x2d, 0xf7, 0x3e, 0xfc, 0x53,
+	0x01, 0xe5, 0x3c, 0xd3, 0xcc, 0x11, 0x57, 0x60, 0xed, 0x39, 0xe2, 0x8a, 0x9c, 0x59, 0xab, 0x31,
+	0x71, 0xef, 0xc2, 0x77, 0x8e, 0xb8, 0x0d, 0x71, 0x0f, 0x3d, 0xf1, 0xb1, 0x22, 0x6d, 0x3f, 0xc7,
+	0xf7, 0xa2, 0xd7, 0xf4, 0xf2, 0xee, 0x45, 0x86, 0xc5, 0xe7, 0xdd, 0x8b, 0x2c, 0xaf, 0xd6, 0xae,
+	0x31, 0xea, 0xaf, 0xc3, 0xab, 0x47, 0xac, 0x57, 0x42, 0x3a, 0xf6, 0xf2, 0x8c, 0x5b, 0xbc, 0x7e,
+	0x7d, 0xef, 0xa0, 0xa2, 0x3c, 0x3c, 0xa8, 0x28, 0x7f, 0x1d, 0x54, 0x94, 0xef, 0x0e, 0x2b, 0xa5,
+	0x87, 0x87, 0x95, 0xd2, 0x1f, 0x87, 0x95, 0xd2, 0x27, 0xcb, 0xb6, 0x43, 0x6f, 0xb6, 0x1b, 0x46,
+	0x93, 0x78, 0x03, 0x00, 0x77, 0xbb, 0x10, 0xb4, 0x13, 0xe0, 0xa8, 0x31, 0xca, 0xfe, 0x9f, 0x58,
+	0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x24, 0xef, 0x81, 0x6b, 0x6e, 0x0d, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/x/reporter/types/tx.pb.go b/x/reporter/types/tx.pb.go
index f38770ae6..6e727c4a6 100644
--- a/x/reporter/types/tx.pb.go
+++ b/x/reporter/types/tx.pb.go
@@ -130,9 +130,9 @@ var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo
 // MsgCreateReporter defines the Msg/CreateReporter request type.
 type MsgCreateReporter struct {
 	// reporter_address is the address of the reporter.
-	ReporterAddress   string                 `protobuf:"bytes,1,opt,name=reporter_address,json=reporterAddress,proto3" json:"reporter_address,omitempty"`
-	CommissionRate    cosmossdk_io_math.Uint `protobuf:"bytes,2,opt,name=commission_rate,json=commissionRate,proto3,customtype=cosmossdk.io/math.Uint" json:"commission_rate"`
-	MinTokensRequired cosmossdk_io_math.Int  `protobuf:"bytes,3,opt,name=min_tokens_required,json=minTokensRequired,proto3,customtype=cosmossdk.io/math.Int" json:"min_tokens_required"`
+	ReporterAddress   string                      `protobuf:"bytes,1,opt,name=reporter_address,json=reporterAddress,proto3" json:"reporter_address,omitempty"`
+	CommissionRate    cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=commission_rate,json=commissionRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"commission_rate"`
+	MinTokensRequired cosmossdk_io_math.Int       `protobuf:"bytes,3,opt,name=min_tokens_required,json=minTokensRequired,proto3,customtype=cosmossdk.io/math.Int" json:"min_tokens_required"`
 }
 
 func (m *MsgCreateReporter) Reset()         { *m = MsgCreateReporter{} }
@@ -672,59 +672,60 @@ func init() {
 func init() { proto.RegisterFile("layer/reporter/tx.proto", fileDescriptor_67b904a7aa978eb1) }
 
 var fileDescriptor_67b904a7aa978eb1 = []byte{
-	// 829 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x3d, 0x4f, 0x1b, 0x49,
-	0x18, 0xf6, 0x1a, 0x81, 0xe4, 0xf1, 0xc9, 0x1f, 0x7b, 0x7c, 0x18, 0x23, 0xd6, 0x60, 0x9d, 0xee,
-	0xf8, 0x90, 0xbd, 0x02, 0xa4, 0x93, 0xa0, 0x3b, 0xa3, 0x2b, 0x28, 0x7c, 0x3a, 0x2d, 0x38, 0x89,
-	0x82, 0x14, 0x6b, 0x6c, 0x8f, 0xd6, 0x13, 0xbc, 0x3b, 0xce, 0xcc, 0x60, 0x70, 0x17, 0xa5, 0x8a,
-	0xd2, 0x24, 0x7f, 0x20, 0x12, 0x4d, 0xa4, 0x94, 0x14, 0x6e, 0x22, 0xe5, 0x07, 0x50, 0x22, 0xaa,
-	0x28, 0x05, 0x8a, 0xa0, 0x20, 0x3f, 0x23, 0xda, 0xdd, 0x59, 0xdb, 0xbb, 0x9e, 0x40, 0x90, 0xd2,
-	0xa4, 0xb1, 0x3d, 0xf3, 0xbe, 0xef, 0x33, 0xcf, 0xf3, 0xec, 0xbc, 0xaf, 0x17, 0xcc, 0xb4, 0x60,
-	0x17, 0x51, 0x9d, 0xa2, 0x36, 0xa1, 0x1c, 0x51, 0x9d, 0x1f, 0x17, 0xdb, 0x94, 0x70, 0xa2, 0x26,
-	0xdc, 0x40, 0xd1, 0x0f, 0x64, 0xd3, 0xd0, 0xc2, 0x36, 0xd1, 0xdd, 0x4f, 0x2f, 0x25, 0xab, 0xd5,
-	0x09, 0xb3, 0x08, 0xd3, 0x6b, 0x90, 0x21, 0xbd, 0xb3, 0x56, 0x43, 0x1c, 0xae, 0xe9, 0x75, 0x82,
-	0x6d, 0x11, 0x9f, 0x11, 0x71, 0x8b, 0x99, 0x7a, 0x67, 0xcd, 0xf9, 0x12, 0x81, 0x3f, 0x44, 0x80,
-	0x71, 0x78, 0x80, 0x6d, 0xb3, 0x5f, 0x2b, 0xd6, 0x22, 0x6b, 0xd6, 0xcb, 0xaa, 0xba, 0x2b, 0xdd,
-	0x5b, 0x88, 0xd0, 0xa4, 0x49, 0x4c, 0xe2, 0xed, 0x3b, 0xbf, 0xc4, 0xee, 0x5c, 0x48, 0x4b, 0x1b,
-	0x52, 0x68, 0xf9, 0x25, 0x8b, 0x61, 0xa1, 0xe4, 0x00, 0xd9, 0x55, 0x42, 0xb1, 0xe9, 0xf3, 0xcd,
-	0x7f, 0x50, 0x40, 0xb2, 0xcc, 0xcc, 0x4a, 0xbb, 0x01, 0x39, 0xfa, 0xdf, 0x2d, 0x56, 0xff, 0x06,
-	0x31, 0x78, 0xc8, 0x9b, 0x84, 0x62, 0xde, 0xcd, 0x28, 0x0b, 0xca, 0x52, 0xac, 0x94, 0xb9, 0xe8,
-	0x15, 0x26, 0x05, 0x9d, 0x7f, 0x1a, 0x0d, 0x8a, 0x18, 0xdb, 0xe5, 0x14, 0xdb, 0xa6, 0x31, 0x48,
-	0x55, 0x37, 0xc1, 0x84, 0x77, 0x7c, 0x26, 0xba, 0xa0, 0x2c, 0xc5, 0xd7, 0xa7, 0x8b, 0x41, 0x3f,
-	0x8b, 0x1e, 0x7e, 0x29, 0x76, 0x76, 0x99, 0x8b, 0xbc, 0xbf, 0x39, 0x5d, 0x51, 0x0c, 0x51, 0xb0,
-	0xb5, 0xf1, 0xe2, 0xe6, 0x74, 0x65, 0x00, 0xf5, 0xea, 0xe6, 0x74, 0x65, 0xc1, 0x23, 0x7f, 0x3c,
-	0xa0, 0x1f, 0xe2, 0x99, 0x9f, 0x05, 0x33, 0xa1, 0x2d, 0x03, 0xb1, 0x36, 0xb1, 0x19, 0xca, 0xbf,
-	0x8e, 0x82, 0x74, 0x99, 0x99, 0xdb, 0x14, 0x41, 0x8e, 0x0c, 0x01, 0xa0, 0x2e, 0x83, 0x94, 0x0f,
-	0x56, 0x85, 0x9e, 0x0a, 0x4f, 0x9f, 0x91, 0xf4, 0xf7, 0x85, 0x38, 0x75, 0x1f, 0x24, 0xeb, 0xc4,
-	0xb2, 0x30, 0x63, 0x98, 0xd8, 0x55, 0x0a, 0x39, 0x72, 0x45, 0xc5, 0x4a, 0xeb, 0x0e, 0xf9, 0xcf,
-	0x97, 0xb9, 0x69, 0xcf, 0x0d, 0xd6, 0x38, 0x28, 0x62, 0xa2, 0x5b, 0x90, 0x37, 0x8b, 0x15, 0x6c,
-	0xf3, 0x8b, 0x5e, 0x21, 0x2e, 0x7c, 0x72, 0x96, 0x9e, 0xca, 0xc4, 0x00, 0xca, 0x80, 0x1c, 0xa9,
-	0xfb, 0xe0, 0x77, 0x0b, 0xdb, 0x55, 0xf7, 0x71, 0xb0, 0x2a, 0x45, 0xcf, 0x0e, 0x31, 0x45, 0x8d,
-	0xcc, 0x98, 0x7b, 0xc0, 0xaa, 0x38, 0x60, 0x6a, 0xf4, 0x80, 0x1d, 0x17, 0x1f, 0x08, 0xfc, 0x1d,
-	0x9b, 0x1b, 0x69, 0x0b, 0xdb, 0x7b, 0x2e, 0x8c, 0x21, 0x50, 0xb6, 0xa6, 0x1c, 0x2b, 0x47, 0x74,
-	0xe6, 0xe7, 0xc0, 0xec, 0x88, 0x21, 0x7d, 0xbb, 0x7a, 0x8a, 0x6b, 0xd7, 0x2e, 0x6a, 0xa1, 0x3a,
-	0xef, 0xdb, 0xb5, 0x0d, 0x52, 0xcc, 0xdd, 0x21, 0x21, 0xbb, 0x6e, 0xb9, 0x0e, 0x49, 0xbf, 0xc2,
-	0x37, 0x72, 0x5b, 0xe2, 0x79, 0xf4, 0x2e, 0x90, 0xd0, 0xd3, 0x10, 0x9a, 0xc2, 0x64, 0x84, 0xa6,
-	0x20, 0xeb, 0x11, 0x4d, 0x47, 0x98, 0xd7, 0x9b, 0xbf, 0x9c, 0xa6, 0x00, 0xeb, 0xbe, 0xa6, 0x77,
-	0x9e, 0x26, 0x03, 0x59, 0xa4, 0x83, 0x76, 0x45, 0xa9, 0xba, 0x09, 0xe2, 0xd0, 0xee, 0xfe, 0xb0,
-	0x1c, 0x00, 0xed, 0xee, 0x90, 0x92, 0x11, 0x3b, 0xa2, 0xf7, 0xb4, 0x63, 0x2b, 0xe5, 0x28, 0x19,
-	0xa6, 0x20, 0x44, 0x04, 0x69, 0xf6, 0x45, 0x1c, 0xb9, 0x1a, 0x2a, 0xf6, 0x53, 0x88, 0x5b, 0xc3,
-	0xcf, 0x45, 0xde, 0x9a, 0xf7, 0xb1, 0x74, 0xfe, 0xe5, 0x49, 0x2e, 0xf2, 0xf5, 0x24, 0x17, 0xb9,
-	0xad, 0x05, 0x82, 0x07, 0xf7, 0x59, 0x7d, 0x54, 0x40, 0xa2, 0xcc, 0xcc, 0x87, 0x98, 0x37, 0x1b,
-	0x14, 0x1e, 0xed, 0xe1, 0xf6, 0xcf, 0xb9, 0x2b, 0xff, 0x81, 0x74, 0x07, 0xb6, 0x70, 0x03, 0x8e,
-	0x5a, 0xbc, 0x78, 0xd1, 0x2b, 0xcc, 0x0b, 0x94, 0x07, 0x7e, 0x4e, 0x10, 0x2e, 0xd5, 0x09, 0xed,
-	0x7f, 0xef, 0xda, 0x64, 0xc0, 0x74, 0x90, 0xbd, 0x2f, 0x6c, 0xfd, 0xed, 0x38, 0x18, 0x2b, 0x33,
-	0x53, 0x7d, 0x04, 0x7e, 0x0b, 0x4c, 0xf9, 0x5c, 0x78, 0x3a, 0x87, 0x66, 0x69, 0xf6, 0xaf, 0x3b,
-	0x12, 0xfc, 0x13, 0xd4, 0x27, 0x20, 0x11, 0x1a, 0xb4, 0x8b, 0x92, 0xd2, 0x60, 0x4a, 0x76, 0xf9,
-	0xce, 0x94, 0x61, 0xfc, 0xd0, 0x64, 0x92, 0xe1, 0x07, 0x53, 0xa4, 0xf8, 0xf2, 0x49, 0xe1, 0xe2,
-	0x07, 0xa7, 0x84, 0x14, 0x3f, 0x90, 0x22, 0xc7, 0x97, 0x76, 0xad, 0x83, 0x1f, 0xea, 0x58, 0x19,
-	0x7e, 0x30, 0x45, 0x8a, 0x2f, 0x6f, 0x28, 0x07, 0x3f, 0xd4, 0x4d, 0x32, 0xfc, 0x60, 0x8a, 0x14,
-	0x5f, 0xde, 0x1a, 0x6a, 0x05, 0xc4, 0x87, 0xdb, 0x42, 0x93, 0x54, 0x0e, 0xc5, 0xb3, 0x7f, 0xde,
-	0x1e, 0xf7, 0x61, 0xb3, 0xe3, 0xcf, 0x9d, 0x3f, 0xc7, 0xd2, 0xbf, 0x67, 0x57, 0x9a, 0x72, 0x7e,
-	0xa5, 0x29, 0x5f, 0xae, 0x34, 0xe5, 0xcd, 0xb5, 0x16, 0x39, 0xbf, 0xd6, 0x22, 0x9f, 0xae, 0xb5,
-	0xc8, 0xe3, 0x55, 0x13, 0xf3, 0xe6, 0x61, 0xad, 0x58, 0x27, 0x96, 0xce, 0x51, 0xab, 0x45, 0x68,
-	0x01, 0x13, 0x7d, 0xe4, 0xb5, 0x80, 0x77, 0xdb, 0x88, 0xd5, 0x26, 0xdc, 0xf7, 0x99, 0x8d, 0x6f,
-	0x01, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xe4, 0xbd, 0x16, 0xdd, 0x09, 0x00, 0x00,
+	// 838 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcf, 0x6b, 0xdb, 0x48,
+	0x14, 0xb6, 0x1c, 0x12, 0xf0, 0x64, 0xf1, 0x0f, 0x6d, 0x7e, 0x38, 0x0e, 0x91, 0x13, 0xb3, 0xec,
+	0xe6, 0x07, 0xb6, 0x48, 0x02, 0x0b, 0x09, 0x7b, 0x59, 0x67, 0xf7, 0x10, 0x58, 0x2f, 0x8b, 0x92,
+	0xec, 0x2e, 0xbb, 0x50, 0x33, 0x96, 0x07, 0x79, 0x1a, 0x4b, 0xe3, 0xce, 0x4c, 0x9c, 0xf8, 0x56,
+	0x7a, 0x2a, 0x3d, 0xf5, 0xda, 0x43, 0x21, 0x97, 0x42, 0x8f, 0x39, 0xf8, 0x52, 0xe8, 0x1f, 0x90,
+	0x63, 0xf0, 0xa9, 0xf4, 0x10, 0x4a, 0x72, 0x48, 0xff, 0x8c, 0x22, 0x69, 0x64, 0x5b, 0xf2, 0x34,
+	0x69, 0xa0, 0x97, 0x5e, 0x6c, 0x6b, 0xde, 0x7b, 0xdf, 0xfb, 0xbe, 0x4f, 0x7a, 0xcf, 0x02, 0xb3,
+	0x4d, 0xd8, 0x41, 0x54, 0xa7, 0xa8, 0x45, 0x28, 0x47, 0x54, 0xe7, 0x27, 0xa5, 0x16, 0x25, 0x9c,
+	0xa8, 0x49, 0x2f, 0x50, 0x0a, 0x02, 0xb9, 0x0c, 0xb4, 0xb1, 0x43, 0x74, 0xef, 0xd3, 0x4f, 0xc9,
+	0x69, 0x26, 0x61, 0x36, 0x61, 0x7a, 0x0d, 0x32, 0xa4, 0xb7, 0xd7, 0x6b, 0x88, 0xc3, 0x75, 0xdd,
+	0x24, 0xd8, 0x11, 0xf1, 0x59, 0x11, 0xb7, 0x99, 0xa5, 0xb7, 0xd7, 0xdd, 0x2f, 0x11, 0xf8, 0x41,
+	0x04, 0x18, 0x87, 0x87, 0xd8, 0xb1, 0xfa, 0xb5, 0xe2, 0x5a, 0x64, 0xcd, 0xf9, 0x59, 0x55, 0xef,
+	0x4a, 0xf7, 0x2f, 0x44, 0x68, 0xca, 0x22, 0x16, 0xf1, 0xcf, 0xdd, 0x5f, 0xe2, 0x74, 0x3e, 0xa2,
+	0xa5, 0x05, 0x29, 0xb4, 0x83, 0x92, 0xa5, 0xa8, 0x50, 0x72, 0x88, 0x9c, 0x2a, 0xa1, 0xd8, 0x0a,
+	0xf8, 0x16, 0xde, 0x28, 0x20, 0x55, 0x61, 0xd6, 0x41, 0xab, 0x0e, 0x39, 0xfa, 0xcb, 0x2b, 0x56,
+	0x7f, 0x06, 0x09, 0x78, 0xc4, 0x1b, 0x84, 0x62, 0xde, 0xc9, 0x2a, 0x8b, 0xca, 0x72, 0xa2, 0x9c,
+	0xed, 0x75, 0x8b, 0x53, 0x82, 0xce, 0xaf, 0xf5, 0x3a, 0x45, 0x8c, 0xed, 0x71, 0x8a, 0x1d, 0xcb,
+	0x18, 0xa4, 0xaa, 0x5b, 0x60, 0xc2, 0x6f, 0x9f, 0x8d, 0x2f, 0x2a, 0xcb, 0x93, 0x1b, 0x33, 0xa5,
+	0xb0, 0x9f, 0x25, 0x1f, 0xbf, 0x9c, 0x38, 0xbf, 0xcc, 0xc7, 0x5e, 0xdf, 0x9c, 0xad, 0x2a, 0x86,
+	0x28, 0xd8, 0xde, 0x7c, 0x72, 0x73, 0xb6, 0x3a, 0x80, 0x7a, 0x76, 0x73, 0xb6, 0xba, 0xe8, 0x93,
+	0x3f, 0x19, 0xd0, 0x8f, 0xf0, 0x2c, 0xcc, 0x81, 0xd9, 0xc8, 0x91, 0x81, 0x58, 0x8b, 0x38, 0x0c,
+	0x15, 0x5e, 0xc4, 0x41, 0xa6, 0xc2, 0xac, 0x1d, 0x8a, 0x20, 0x47, 0x86, 0x00, 0x50, 0x57, 0x40,
+	0x3a, 0x00, 0xab, 0x42, 0x5f, 0x85, 0xaf, 0xcf, 0x48, 0x05, 0xe7, 0x42, 0x9c, 0x8a, 0x40, 0xca,
+	0x24, 0xb6, 0x8d, 0x19, 0xc3, 0xc4, 0xa9, 0x52, 0xc8, 0x91, 0x27, 0x2a, 0x51, 0xfe, 0xc5, 0x25,
+	0xff, 0xfe, 0x32, 0x3f, 0xef, 0xbb, 0xc1, 0xea, 0x87, 0x25, 0x4c, 0x74, 0x1b, 0xf2, 0x46, 0xe9,
+	0x0f, 0x64, 0x41, 0xb3, 0xf3, 0x1b, 0x32, 0x7b, 0xdd, 0x62, 0x5a, 0x98, 0xd5, 0x3f, 0xf3, 0xf5,
+	0x26, 0x07, 0xa0, 0x06, 0xe4, 0x48, 0xfd, 0x1f, 0x7c, 0x6f, 0x63, 0xa7, 0xea, 0xdd, 0x18, 0x56,
+	0xa5, 0xe8, 0xd1, 0x11, 0xa6, 0xa8, 0x9e, 0x1d, 0xf3, 0x5a, 0xad, 0x89, 0x56, 0xd3, 0xa3, 0xad,
+	0x76, 0x1d, 0xde, 0xeb, 0x16, 0x81, 0x68, 0xb2, 0xeb, 0x70, 0x23, 0x63, 0x63, 0x67, 0xdf, 0x83,
+	0x31, 0x04, 0xca, 0xf6, 0xb4, 0x6b, 0xea, 0x88, 0xe2, 0xc2, 0x3c, 0x98, 0x1b, 0xb1, 0xa6, 0x6f,
+	0x5c, 0x57, 0xf1, 0x8c, 0xdb, 0x43, 0x4d, 0x64, 0xf2, 0xbe, 0x71, 0x3b, 0x20, 0xcd, 0xbc, 0x13,
+	0x12, 0x31, 0xee, 0x96, 0x07, 0x23, 0x15, 0x54, 0x04, 0x96, 0xee, 0x48, 0xdc, 0x8f, 0xdf, 0x05,
+	0x12, 0xb9, 0x2f, 0x42, 0x53, 0x94, 0x8c, 0xd0, 0x14, 0x66, 0x3d, 0xa2, 0xe9, 0x18, 0x73, 0xb3,
+	0xf1, 0xcd, 0x69, 0x0a, 0xb1, 0xee, 0x6b, 0x7a, 0xe5, 0x6b, 0x32, 0x90, 0x4d, 0xda, 0x68, 0x4f,
+	0x94, 0xaa, 0x5b, 0x60, 0x12, 0x3a, 0x9d, 0x2f, 0x96, 0x03, 0xa0, 0xd3, 0x19, 0x52, 0x32, 0x62,
+	0x47, 0xfc, 0x9e, 0x76, 0x6c, 0xa7, 0x5d, 0x25, 0xc3, 0x14, 0x84, 0x88, 0x30, 0xcd, 0xbe, 0x88,
+	0x63, 0x4f, 0xc3, 0x81, 0xf3, 0x10, 0xe2, 0xe6, 0xf0, 0x7d, 0x91, 0x0f, 0xe9, 0x7d, 0x2c, 0x5d,
+	0x78, 0x7a, 0x9a, 0x8f, 0x7d, 0x3c, 0xcd, 0xc7, 0x6e, 0x1b, 0x81, 0x70, 0xe3, 0x3e, 0xab, 0xb7,
+	0x0a, 0x48, 0x56, 0x98, 0xf5, 0x0f, 0xe6, 0x8d, 0x3a, 0x85, 0xc7, 0xfb, 0xb8, 0xf5, 0x75, 0x9e,
+	0x95, 0x3f, 0x41, 0xa6, 0x0d, 0x9b, 0xb8, 0x0e, 0x47, 0x2d, 0x5e, 0xea, 0x75, 0x8b, 0x0b, 0x02,
+	0xe5, 0xef, 0x20, 0x27, 0x0c, 0x97, 0x6e, 0x47, 0xce, 0x3f, 0xf7, 0xd8, 0x64, 0xc1, 0x4c, 0x98,
+	0x7d, 0x20, 0x6c, 0xe3, 0xe5, 0x38, 0x18, 0xab, 0x30, 0x4b, 0xfd, 0x17, 0x7c, 0x17, 0xda, 0xf7,
+	0xf9, 0xe8, 0x9e, 0x8e, 0x6c, 0xd5, 0xdc, 0x4f, 0x77, 0x24, 0x04, 0x1d, 0xd4, 0x07, 0x20, 0x19,
+	0x59, 0xb9, 0x4b, 0x92, 0xd2, 0x70, 0x4a, 0x6e, 0xe5, 0xce, 0x94, 0x61, 0xfc, 0xc8, 0x66, 0x92,
+	0xe1, 0x87, 0x53, 0xa4, 0xf8, 0xf2, 0x4d, 0xe1, 0xe1, 0x87, 0xb7, 0x84, 0x14, 0x3f, 0x94, 0x22,
+	0xc7, 0x97, 0x4e, 0xad, 0x8b, 0x1f, 0x99, 0x58, 0x19, 0x7e, 0x38, 0x45, 0x8a, 0x2f, 0x1f, 0x28,
+	0x17, 0x3f, 0x32, 0x4d, 0x32, 0xfc, 0x70, 0x8a, 0x14, 0x5f, 0x3e, 0x1a, 0xea, 0x01, 0x98, 0x1c,
+	0x1e, 0x0b, 0x4d, 0x52, 0x39, 0x14, 0xcf, 0xfd, 0x78, 0x7b, 0x3c, 0x80, 0xcd, 0x8d, 0x3f, 0x76,
+	0xff, 0x1c, 0xcb, 0xbf, 0x9f, 0x5f, 0x69, 0xca, 0xc5, 0x95, 0xa6, 0x7c, 0xb8, 0xd2, 0x94, 0xe7,
+	0xd7, 0x5a, 0xec, 0xe2, 0x5a, 0x8b, 0xbd, 0xbb, 0xd6, 0x62, 0xff, 0xad, 0x59, 0x98, 0x37, 0x8e,
+	0x6a, 0x25, 0x93, 0xd8, 0x3a, 0x47, 0xcd, 0x26, 0xa1, 0x45, 0x4c, 0xf4, 0x91, 0x17, 0x04, 0xde,
+	0x69, 0x21, 0x56, 0x9b, 0xf0, 0xde, 0x6c, 0x36, 0x3f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x5a, 0x39,
+	0x08, 0xd7, 0xe7, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.