// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/v9/tx.proto

package types

import (
	context "context"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	github_com_allora_network_allora_chain_math "github.com/allora-network/allora-chain/math"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Because gocosmos, grpc-gateway, and go-pulsar do not support optional fields
// and including google themselves
// https://cloud.google.com/apis/design/design_patterns.md#optional_primitive_fields
// we instead use a repeated field with a single element to represent an
// optional field and if the repeated field is empty, it is considered to be the
// same as if the field was not set
type OptionalParams struct {
	Version                             []string                                          `protobuf:"bytes,1,rep,name=version,proto3" json:"version,omitempty"`
	MaxSerializedMsgLength              []int64                                           `protobuf:"varint,2,rep,packed,name=max_serialized_msg_length,json=maxSerializedMsgLength,proto3" json:"max_serialized_msg_length,omitempty"`
	MinTopicWeight                      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,rep,name=min_topic_weight,json=minTopicWeight,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_topic_weight"`
	RequiredMinimumStake                []cosmossdk_io_math.Int                           `protobuf:"bytes,5,rep,name=required_minimum_stake,json=requiredMinimumStake,proto3,customtype=cosmossdk.io/math.Int" json:"required_minimum_stake"`
	RemoveStakeDelayWindow              []int64                                           `protobuf:"varint,6,rep,packed,name=remove_stake_delay_window,json=removeStakeDelayWindow,proto3" json:"remove_stake_delay_window,omitempty"`
	MinEpochLength                      []int64                                           `protobuf:"varint,7,rep,packed,name=min_epoch_length,json=minEpochLength,proto3" json:"min_epoch_length,omitempty"`
	BetaEntropy                         []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,8,rep,name=beta_entropy,json=betaEntropy,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"beta_entropy"`
	LearningRate                        []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,9,rep,name=learning_rate,json=learningRate,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"learning_rate"`
	MaxGradientThreshold                []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,10,rep,name=max_gradient_threshold,json=maxGradientThreshold,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"max_gradient_threshold"`
	MinStakeFraction                    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,11,rep,name=min_stake_fraction,json=minStakeFraction,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_stake_fraction"`
	MaxUnfulfilledWorkerRequests        []uint64                                          `protobuf:"varint,13,rep,packed,name=max_unfulfilled_worker_requests,json=maxUnfulfilledWorkerRequests,proto3" json:"max_unfulfilled_worker_requests,omitempty"`
	MaxUnfulfilledReputerRequests       []uint64                                          `protobuf:"varint,14,rep,packed,name=max_unfulfilled_reputer_requests,json=maxUnfulfilledReputerRequests,proto3" json:"max_unfulfilled_reputer_requests,omitempty"`
	TopicRewardStakeImportance          []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,15,rep,name=topic_reward_stake_importance,json=topicRewardStakeImportance,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_stake_importance"`
	TopicRewardFeeRevenueImportance     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,16,rep,name=topic_reward_fee_revenue_importance,json=topicRewardFeeRevenueImportance,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_fee_revenue_importance"`
	TopicRewardAlpha                    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,17,rep,name=topic_reward_alpha,json=topicRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_alpha"`
	TaskRewardAlpha                     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,18,rep,name=task_reward_alpha,json=taskRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"task_reward_alpha"`
	ValidatorsVsAlloraPercentReward     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,19,rep,name=validators_vs_allora_percent_reward,json=validatorsVsAlloraPercentReward,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"validators_vs_allora_percent_reward"`
	MaxSamplesToScaleScores             []uint64                                          `protobuf:"varint,20,rep,packed,name=max_samples_to_scale_scores,json=maxSamplesToScaleScores,proto3" json:"max_samples_to_scale_scores,omitempty"`
	MaxTopInferersToReward              []uint64                                          `protobuf:"varint,21,rep,packed,name=max_top_inferers_to_reward,json=maxTopInferersToReward,proto3" json:"max_top_inferers_to_reward,omitempty"`
	MaxTopForecastersToReward           []uint64                                          `protobuf:"varint,22,rep,packed,name=max_top_forecasters_to_reward,json=maxTopForecastersToReward,proto3" json:"max_top_forecasters_to_reward,omitempty"`
	MaxTopReputersToReward              []uint64                                          `protobuf:"varint,23,rep,packed,name=max_top_reputers_to_reward,json=maxTopReputersToReward,proto3" json:"max_top_reputers_to_reward,omitempty"`
	CreateTopicFee                      []cosmossdk_io_math.Int                           `protobuf:"bytes,24,rep,name=create_topic_fee,json=createTopicFee,proto3,customtype=cosmossdk.io/math.Int" json:"create_topic_fee"`
	GradientDescentMaxIters             []uint64                                          `protobuf:"varint,25,rep,packed,name=gradient_descent_max_iters,json=gradientDescentMaxIters,proto3" json:"gradient_descent_max_iters,omitempty"`
	RegistrationFee                     []cosmossdk_io_math.Int                           `protobuf:"bytes,28,rep,name=registration_fee,json=registrationFee,proto3,customtype=cosmossdk.io/math.Int" json:"registration_fee"`
	DefaultPageLimit                    []uint64                                          `protobuf:"varint,29,rep,packed,name=default_page_limit,json=defaultPageLimit,proto3" json:"default_page_limit,omitempty"`
	MaxPageLimit                        []uint64                                          `protobuf:"varint,30,rep,packed,name=max_page_limit,json=maxPageLimit,proto3" json:"max_page_limit,omitempty"`
	MinEpochLengthRecordLimit           []int64                                           `protobuf:"varint,31,rep,packed,name=min_epoch_length_record_limit,json=minEpochLengthRecordLimit,proto3" json:"min_epoch_length_record_limit,omitempty"`
	BlocksPerMonth                      []uint64                                          `protobuf:"varint,32,rep,packed,name=blocks_per_month,json=blocksPerMonth,proto3" json:"blocks_per_month,omitempty"`
	PRewardInference                    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,33,rep,name=p_reward_inference,json=pRewardInference,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_inference"`
	PRewardForecast                     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,34,rep,name=p_reward_forecast,json=pRewardForecast,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_forecast"`
	PRewardReputer                      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,35,rep,name=p_reward_reputer,json=pRewardReputer,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_reputer"`
	CRewardInference                    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,36,rep,name=c_reward_inference,json=cRewardInference,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_reward_inference"`
	CRewardForecast                     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,37,rep,name=c_reward_forecast,json=cRewardForecast,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_reward_forecast"`
	CNorm                               []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,38,rep,name=c_norm,json=cNorm,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_norm"`
	EpsilonReputer                      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,40,rep,name=epsilon_reputer,json=epsilonReputer,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon_reputer"`
	HalfMaxProcessStakeRemovalsEndBlock []uint64                                          `protobuf:"varint,42,rep,packed,name=half_max_process_stake_removals_end_block,json=halfMaxProcessStakeRemovalsEndBlock,proto3" json:"half_max_process_stake_removals_end_block,omitempty"`
	DataSendingFee                      []cosmossdk_io_math.Int                           `protobuf:"bytes,43,rep,name=data_sending_fee,json=dataSendingFee,proto3,customtype=cosmossdk.io/math.Int" json:"data_sending_fee"`
	EpsilonSafeDiv                      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,44,rep,name=epsilon_safe_div,json=epsilonSafeDiv,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon_safe_div"`
	MaxElementsPerForecast              []uint64                                          `protobuf:"varint,45,rep,packed,name=max_elements_per_forecast,json=maxElementsPerForecast,proto3" json:"max_elements_per_forecast,omitempty"`
	MaxActiveTopicsPerBlock             []uint64                                          `protobuf:"varint,46,rep,packed,name=max_active_topics_per_block,json=maxActiveTopicsPerBlock,proto3" json:"max_active_topics_per_block,omitempty"`
	MaxStringLength                     []uint64                                          `protobuf:"varint,47,rep,packed,name=max_string_length,json=maxStringLength,proto3" json:"max_string_length,omitempty"`
	InitialRegretQuantile               []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,48,rep,name=initial_regret_quantile,json=initialRegretQuantile,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"initial_regret_quantile"`
	PNormSafeDiv                        []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,49,rep,name=p_norm_safe_div,json=pNormSafeDiv,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_norm_safe_div"`
	GlobalWhitelistEnabled              []bool                                            `protobuf:"varint,50,rep,packed,name=global_whitelist_enabled,json=globalWhitelistEnabled,proto3" json:"global_whitelist_enabled,omitempty"`
	TopicCreatorWhitelistEnabled        []bool                                            `protobuf:"varint,51,rep,packed,name=topic_creator_whitelist_enabled,json=topicCreatorWhitelistEnabled,proto3" json:"topic_creator_whitelist_enabled,omitempty"`
	MinExperiencedWorkerRegrets         []uint64                                          `protobuf:"varint,52,rep,packed,name=min_experienced_worker_regrets,json=minExperiencedWorkerRegrets,proto3" json:"min_experienced_worker_regrets,omitempty"`
	InferenceOutlierDetectionThreshold  []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,53,rep,name=inference_outlier_detection_threshold,json=inferenceOutlierDetectionThreshold,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"inference_outlier_detection_threshold"`
	InferenceOutlierDetectionAlpha      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,54,rep,name=inference_outlier_detection_alpha,json=inferenceOutlierDetectionAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"inference_outlier_detection_alpha"`
	LambdaInitialScore                  []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,55,rep,name=lambda_initial_score,json=lambdaInitialScore,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"lambda_initial_score"`
	GlobalWorkerWhitelistEnabled        []bool                                            `protobuf:"varint,56,rep,packed,name=global_worker_whitelist_enabled,json=globalWorkerWhitelistEnabled,proto3" json:"global_worker_whitelist_enabled,omitempty"`
	GlobalReputerWhitelistEnabled       []bool                                            `protobuf:"varint,57,rep,packed,name=global_reputer_whitelist_enabled,json=globalReputerWhitelistEnabled,proto3" json:"global_reputer_whitelist_enabled,omitempty"`
	GlobalAdminWhitelistAppended        []bool                                            `protobuf:"varint,58,rep,packed,name=global_admin_whitelist_appended,json=globalAdminWhitelistAppended,proto3" json:"global_admin_whitelist_appended,omitempty"`
	MaxWhitelistInputArrayLength        []uint64                                          `protobuf:"varint,59,rep,packed,name=max_whitelist_input_array_length,json=maxWhitelistInputArrayLength,proto3" json:"max_whitelist_input_array_length,omitempty"`
	MinWeightThresholdForStdnorm        []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,60,rep,name=min_weight_threshold_for_stdnorm,json=minWeightThresholdForStdnorm,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_weight_threshold_for_stdnorm"`
}

func (m *OptionalParams) Reset()         { *m = OptionalParams{} }
func (m *OptionalParams) String() string { return proto.CompactTextString(m) }
func (*OptionalParams) ProtoMessage()    {}
func (*OptionalParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{0}
}
func (m *OptionalParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OptionalParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OptionalParams.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 *OptionalParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OptionalParams.Merge(m, src)
}
func (m *OptionalParams) XXX_Size() int {
	return m.Size()
}
func (m *OptionalParams) XXX_DiscardUnknown() {
	xxx_messageInfo_OptionalParams.DiscardUnknown(m)
}

var xxx_messageInfo_OptionalParams proto.InternalMessageInfo

func (m *OptionalParams) GetVersion() []string {
	if m != nil {
		return m.Version
	}
	return nil
}

func (m *OptionalParams) GetMaxSerializedMsgLength() []int64 {
	if m != nil {
		return m.MaxSerializedMsgLength
	}
	return nil
}

func (m *OptionalParams) GetRemoveStakeDelayWindow() []int64 {
	if m != nil {
		return m.RemoveStakeDelayWindow
	}
	return nil
}

func (m *OptionalParams) GetMinEpochLength() []int64 {
	if m != nil {
		return m.MinEpochLength
	}
	return nil
}

func (m *OptionalParams) GetMaxUnfulfilledWorkerRequests() []uint64 {
	if m != nil {
		return m.MaxUnfulfilledWorkerRequests
	}
	return nil
}

func (m *OptionalParams) GetMaxUnfulfilledReputerRequests() []uint64 {
	if m != nil {
		return m.MaxUnfulfilledReputerRequests
	}
	return nil
}

func (m *OptionalParams) GetMaxSamplesToScaleScores() []uint64 {
	if m != nil {
		return m.MaxSamplesToScaleScores
	}
	return nil
}

func (m *OptionalParams) GetMaxTopInferersToReward() []uint64 {
	if m != nil {
		return m.MaxTopInferersToReward
	}
	return nil
}

func (m *OptionalParams) GetMaxTopForecastersToReward() []uint64 {
	if m != nil {
		return m.MaxTopForecastersToReward
	}
	return nil
}

func (m *OptionalParams) GetMaxTopReputersToReward() []uint64 {
	if m != nil {
		return m.MaxTopReputersToReward
	}
	return nil
}

func (m *OptionalParams) GetGradientDescentMaxIters() []uint64 {
	if m != nil {
		return m.GradientDescentMaxIters
	}
	return nil
}

func (m *OptionalParams) GetDefaultPageLimit() []uint64 {
	if m != nil {
		return m.DefaultPageLimit
	}
	return nil
}

func (m *OptionalParams) GetMaxPageLimit() []uint64 {
	if m != nil {
		return m.MaxPageLimit
	}
	return nil
}

func (m *OptionalParams) GetMinEpochLengthRecordLimit() []int64 {
	if m != nil {
		return m.MinEpochLengthRecordLimit
	}
	return nil
}

func (m *OptionalParams) GetBlocksPerMonth() []uint64 {
	if m != nil {
		return m.BlocksPerMonth
	}
	return nil
}

func (m *OptionalParams) GetHalfMaxProcessStakeRemovalsEndBlock() []uint64 {
	if m != nil {
		return m.HalfMaxProcessStakeRemovalsEndBlock
	}
	return nil
}

func (m *OptionalParams) GetMaxElementsPerForecast() []uint64 {
	if m != nil {
		return m.MaxElementsPerForecast
	}
	return nil
}

func (m *OptionalParams) GetMaxActiveTopicsPerBlock() []uint64 {
	if m != nil {
		return m.MaxActiveTopicsPerBlock
	}
	return nil
}

func (m *OptionalParams) GetMaxStringLength() []uint64 {
	if m != nil {
		return m.MaxStringLength
	}
	return nil
}

func (m *OptionalParams) GetGlobalWhitelistEnabled() []bool {
	if m != nil {
		return m.GlobalWhitelistEnabled
	}
	return nil
}

func (m *OptionalParams) GetTopicCreatorWhitelistEnabled() []bool {
	if m != nil {
		return m.TopicCreatorWhitelistEnabled
	}
	return nil
}

func (m *OptionalParams) GetMinExperiencedWorkerRegrets() []uint64 {
	if m != nil {
		return m.MinExperiencedWorkerRegrets
	}
	return nil
}

func (m *OptionalParams) GetGlobalWorkerWhitelistEnabled() []bool {
	if m != nil {
		return m.GlobalWorkerWhitelistEnabled
	}
	return nil
}

func (m *OptionalParams) GetGlobalReputerWhitelistEnabled() []bool {
	if m != nil {
		return m.GlobalReputerWhitelistEnabled
	}
	return nil
}

func (m *OptionalParams) GetGlobalAdminWhitelistAppended() []bool {
	if m != nil {
		return m.GlobalAdminWhitelistAppended
	}
	return nil
}

func (m *OptionalParams) GetMaxWhitelistInputArrayLength() []uint64 {
	if m != nil {
		return m.MaxWhitelistInputArrayLength
	}
	return nil
}

type UpdateParamsRequest struct {
	Sender string          `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Params *OptionalParams `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
}

func (m *UpdateParamsRequest) Reset()         { *m = UpdateParamsRequest{} }
func (m *UpdateParamsRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateParamsRequest) ProtoMessage()    {}
func (*UpdateParamsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{1}
}
func (m *UpdateParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateParamsRequest.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 *UpdateParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateParamsRequest.Merge(m, src)
}
func (m *UpdateParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateParamsRequest proto.InternalMessageInfo

func (m *UpdateParamsRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *UpdateParamsRequest) GetParams() *OptionalParams {
	if m != nil {
		return m.Params
	}
	return nil
}

type UpdateParamsResponse struct {
}

func (m *UpdateParamsResponse) Reset()         { *m = UpdateParamsResponse{} }
func (m *UpdateParamsResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateParamsResponse) ProtoMessage()    {}
func (*UpdateParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{2}
}
func (m *UpdateParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateParamsResponse.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 *UpdateParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateParamsResponse.Merge(m, src)
}
func (m *UpdateParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *UpdateParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateParamsResponse proto.InternalMessageInfo

type CreateNewTopicRequest struct {
	// creator is the message sender.
	Creator                  string                                          `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Metadata                 string                                          `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	LossMethod               string                                          `protobuf:"bytes,4,opt,name=loss_method,json=lossMethod,proto3" json:"loss_method,omitempty"`
	EpochLength              int64                                           `protobuf:"varint,7,opt,name=epoch_length,json=epochLength,proto3" json:"epoch_length,omitempty"`
	GroundTruthLag           int64                                           `protobuf:"varint,8,opt,name=ground_truth_lag,json=groundTruthLag,proto3" json:"ground_truth_lag,omitempty"`
	PNorm                    github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,10,opt,name=p_norm,json=pNorm,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_norm"`
	AlphaRegret              github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,11,opt,name=alpha_regret,json=alphaRegret,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"alpha_regret"`
	AllowNegative            bool                                            `protobuf:"varint,12,opt,name=allow_negative,json=allowNegative,proto3" json:"allow_negative,omitempty"`
	Epsilon                  github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,13,opt,name=epsilon,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon"`
	WorkerSubmissionWindow   int64                                           `protobuf:"varint,14,opt,name=worker_submission_window,json=workerSubmissionWindow,proto3" json:"worker_submission_window,omitempty"`
	MeritSortitionAlpha      github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,15,opt,name=merit_sortition_alpha,json=meritSortitionAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"merit_sortition_alpha"`
	ActiveInfererQuantile    github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,16,opt,name=active_inferer_quantile,json=activeInfererQuantile,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"active_inferer_quantile"`
	ActiveForecasterQuantile github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,17,opt,name=active_forecaster_quantile,json=activeForecasterQuantile,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"active_forecaster_quantile"`
	ActiveReputerQuantile    github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,18,opt,name=active_reputer_quantile,json=activeReputerQuantile,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"active_reputer_quantile"`
	EnableWorkerWhitelist    bool                                            `protobuf:"varint,19,opt,name=enable_worker_whitelist,json=enableWorkerWhitelist,proto3" json:"enable_worker_whitelist,omitempty"`
	EnableReputerWhitelist   bool                                            `protobuf:"varint,20,opt,name=enable_reputer_whitelist,json=enableReputerWhitelist,proto3" json:"enable_reputer_whitelist,omitempty"`
}

func (m *CreateNewTopicRequest) Reset()         { *m = CreateNewTopicRequest{} }
func (m *CreateNewTopicRequest) String() string { return proto.CompactTextString(m) }
func (*CreateNewTopicRequest) ProtoMessage()    {}
func (*CreateNewTopicRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{3}
}
func (m *CreateNewTopicRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateNewTopicRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateNewTopicRequest.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 *CreateNewTopicRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateNewTopicRequest.Merge(m, src)
}
func (m *CreateNewTopicRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateNewTopicRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateNewTopicRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateNewTopicRequest proto.InternalMessageInfo

func (m *CreateNewTopicRequest) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *CreateNewTopicRequest) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

func (m *CreateNewTopicRequest) GetLossMethod() string {
	if m != nil {
		return m.LossMethod
	}
	return ""
}

func (m *CreateNewTopicRequest) GetEpochLength() int64 {
	if m != nil {
		return m.EpochLength
	}
	return 0
}

func (m *CreateNewTopicRequest) GetGroundTruthLag() int64 {
	if m != nil {
		return m.GroundTruthLag
	}
	return 0
}

func (m *CreateNewTopicRequest) GetAllowNegative() bool {
	if m != nil {
		return m.AllowNegative
	}
	return false
}

func (m *CreateNewTopicRequest) GetWorkerSubmissionWindow() int64 {
	if m != nil {
		return m.WorkerSubmissionWindow
	}
	return 0
}

func (m *CreateNewTopicRequest) GetEnableWorkerWhitelist() bool {
	if m != nil {
		return m.EnableWorkerWhitelist
	}
	return false
}

func (m *CreateNewTopicRequest) GetEnableReputerWhitelist() bool {
	if m != nil {
		return m.EnableReputerWhitelist
	}
	return false
}

type CreateNewTopicResponse struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *CreateNewTopicResponse) Reset()         { *m = CreateNewTopicResponse{} }
func (m *CreateNewTopicResponse) String() string { return proto.CompactTextString(m) }
func (*CreateNewTopicResponse) ProtoMessage()    {}
func (*CreateNewTopicResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{4}
}
func (m *CreateNewTopicResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateNewTopicResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateNewTopicResponse.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 *CreateNewTopicResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateNewTopicResponse.Merge(m, src)
}
func (m *CreateNewTopicResponse) XXX_Size() int {
	return m.Size()
}
func (m *CreateNewTopicResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateNewTopicResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateNewTopicResponse proto.InternalMessageInfo

func (m *CreateNewTopicResponse) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type InsertReputerPayloadRequest struct {
	Sender             string                   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	ReputerValueBundle *InputReputerValueBundle `protobuf:"bytes,2,opt,name=reputer_value_bundle,json=reputerValueBundle,proto3" json:"reputer_value_bundle,omitempty"`
}

func (m *InsertReputerPayloadRequest) Reset()         { *m = InsertReputerPayloadRequest{} }
func (m *InsertReputerPayloadRequest) String() string { return proto.CompactTextString(m) }
func (*InsertReputerPayloadRequest) ProtoMessage()    {}
func (*InsertReputerPayloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{5}
}
func (m *InsertReputerPayloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InsertReputerPayloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InsertReputerPayloadRequest.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 *InsertReputerPayloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertReputerPayloadRequest.Merge(m, src)
}
func (m *InsertReputerPayloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *InsertReputerPayloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertReputerPayloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InsertReputerPayloadRequest proto.InternalMessageInfo

func (m *InsertReputerPayloadRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *InsertReputerPayloadRequest) GetReputerValueBundle() *InputReputerValueBundle {
	if m != nil {
		return m.ReputerValueBundle
	}
	return nil
}

type InsertReputerPayloadResponse struct {
}

func (m *InsertReputerPayloadResponse) Reset()         { *m = InsertReputerPayloadResponse{} }
func (m *InsertReputerPayloadResponse) String() string { return proto.CompactTextString(m) }
func (*InsertReputerPayloadResponse) ProtoMessage()    {}
func (*InsertReputerPayloadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{6}
}
func (m *InsertReputerPayloadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InsertReputerPayloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InsertReputerPayloadResponse.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 *InsertReputerPayloadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertReputerPayloadResponse.Merge(m, src)
}
func (m *InsertReputerPayloadResponse) XXX_Size() int {
	return m.Size()
}
func (m *InsertReputerPayloadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertReputerPayloadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_InsertReputerPayloadResponse proto.InternalMessageInfo

type InsertWorkerPayloadRequest struct {
	Sender           string                 `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	WorkerDataBundle *InputWorkerDataBundle `protobuf:"bytes,2,opt,name=worker_data_bundle,json=workerDataBundle,proto3" json:"worker_data_bundle,omitempty"`
}

func (m *InsertWorkerPayloadRequest) Reset()         { *m = InsertWorkerPayloadRequest{} }
func (m *InsertWorkerPayloadRequest) String() string { return proto.CompactTextString(m) }
func (*InsertWorkerPayloadRequest) ProtoMessage()    {}
func (*InsertWorkerPayloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{7}
}
func (m *InsertWorkerPayloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InsertWorkerPayloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InsertWorkerPayloadRequest.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 *InsertWorkerPayloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertWorkerPayloadRequest.Merge(m, src)
}
func (m *InsertWorkerPayloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *InsertWorkerPayloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertWorkerPayloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InsertWorkerPayloadRequest proto.InternalMessageInfo

func (m *InsertWorkerPayloadRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *InsertWorkerPayloadRequest) GetWorkerDataBundle() *InputWorkerDataBundle {
	if m != nil {
		return m.WorkerDataBundle
	}
	return nil
}

type InsertWorkerPayloadResponse struct {
}

func (m *InsertWorkerPayloadResponse) Reset()         { *m = InsertWorkerPayloadResponse{} }
func (m *InsertWorkerPayloadResponse) String() string { return proto.CompactTextString(m) }
func (*InsertWorkerPayloadResponse) ProtoMessage()    {}
func (*InsertWorkerPayloadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{8}
}
func (m *InsertWorkerPayloadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InsertWorkerPayloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InsertWorkerPayloadResponse.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 *InsertWorkerPayloadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertWorkerPayloadResponse.Merge(m, src)
}
func (m *InsertWorkerPayloadResponse) XXX_Size() int {
	return m.Size()
}
func (m *InsertWorkerPayloadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertWorkerPayloadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_InsertWorkerPayloadResponse proto.InternalMessageInfo

type RegisterRequest struct {
	Sender    string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId   uint64 `protobuf:"varint,4,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Owner     string `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"`
	IsReputer bool   `protobuf:"varint,6,opt,name=is_reputer,json=isReputer,proto3" json:"is_reputer,omitempty"`
}

func (m *RegisterRequest) Reset()         { *m = RegisterRequest{} }
func (m *RegisterRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterRequest) ProtoMessage()    {}
func (*RegisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{9}
}
func (m *RegisterRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterRequest.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 *RegisterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterRequest.Merge(m, src)
}
func (m *RegisterRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterRequest proto.InternalMessageInfo

func (m *RegisterRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RegisterRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *RegisterRequest) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *RegisterRequest) GetIsReputer() bool {
	if m != nil {
		return m.IsReputer
	}
	return false
}

type RegisterResponse struct {
	Success bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *RegisterResponse) Reset()         { *m = RegisterResponse{} }
func (m *RegisterResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterResponse) ProtoMessage()    {}
func (*RegisterResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{10}
}
func (m *RegisterResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterResponse.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 *RegisterResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterResponse.Merge(m, src)
}
func (m *RegisterResponse) XXX_Size() int {
	return m.Size()
}
func (m *RegisterResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterResponse proto.InternalMessageInfo

func (m *RegisterResponse) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *RegisterResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type RemoveRegistrationRequest struct {
	Sender    string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId   uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	IsReputer bool   `protobuf:"varint,3,opt,name=is_reputer,json=isReputer,proto3" json:"is_reputer,omitempty"`
}

func (m *RemoveRegistrationRequest) Reset()         { *m = RemoveRegistrationRequest{} }
func (m *RemoveRegistrationRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveRegistrationRequest) ProtoMessage()    {}
func (*RemoveRegistrationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{11}
}
func (m *RemoveRegistrationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveRegistrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveRegistrationRequest.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 *RemoveRegistrationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveRegistrationRequest.Merge(m, src)
}
func (m *RemoveRegistrationRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveRegistrationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveRegistrationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveRegistrationRequest proto.InternalMessageInfo

func (m *RemoveRegistrationRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveRegistrationRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *RemoveRegistrationRequest) GetIsReputer() bool {
	if m != nil {
		return m.IsReputer
	}
	return false
}

type RemoveRegistrationResponse struct {
	Success bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *RemoveRegistrationResponse) Reset()         { *m = RemoveRegistrationResponse{} }
func (m *RemoveRegistrationResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveRegistrationResponse) ProtoMessage()    {}
func (*RemoveRegistrationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{12}
}
func (m *RemoveRegistrationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveRegistrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveRegistrationResponse.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 *RemoveRegistrationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveRegistrationResponse.Merge(m, src)
}
func (m *RemoveRegistrationResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveRegistrationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveRegistrationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveRegistrationResponse proto.InternalMessageInfo

func (m *RemoveRegistrationResponse) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *RemoveRegistrationResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type AddStakeRequest struct {
	Sender  string                `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64                `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func (m *AddStakeRequest) Reset()         { *m = AddStakeRequest{} }
func (m *AddStakeRequest) String() string { return proto.CompactTextString(m) }
func (*AddStakeRequest) ProtoMessage()    {}
func (*AddStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{13}
}
func (m *AddStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddStakeRequest.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 *AddStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddStakeRequest.Merge(m, src)
}
func (m *AddStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddStakeRequest proto.InternalMessageInfo

func (m *AddStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type AddStakeResponse struct {
}

func (m *AddStakeResponse) Reset()         { *m = AddStakeResponse{} }
func (m *AddStakeResponse) String() string { return proto.CompactTextString(m) }
func (*AddStakeResponse) ProtoMessage()    {}
func (*AddStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{14}
}
func (m *AddStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddStakeResponse.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 *AddStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddStakeResponse.Merge(m, src)
}
func (m *AddStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddStakeResponse proto.InternalMessageInfo

type RemoveStakeRequest struct {
	Sender  string                `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64                `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func (m *RemoveStakeRequest) Reset()         { *m = RemoveStakeRequest{} }
func (m *RemoveStakeRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveStakeRequest) ProtoMessage()    {}
func (*RemoveStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{15}
}
func (m *RemoveStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveStakeRequest.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 *RemoveStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveStakeRequest.Merge(m, src)
}
func (m *RemoveStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveStakeRequest proto.InternalMessageInfo

func (m *RemoveStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type RemoveStakeResponse struct {
}

func (m *RemoveStakeResponse) Reset()         { *m = RemoveStakeResponse{} }
func (m *RemoveStakeResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveStakeResponse) ProtoMessage()    {}
func (*RemoveStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{16}
}
func (m *RemoveStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveStakeResponse.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 *RemoveStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveStakeResponse.Merge(m, src)
}
func (m *RemoveStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveStakeResponse proto.InternalMessageInfo

type CancelRemoveStakeRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *CancelRemoveStakeRequest) Reset()         { *m = CancelRemoveStakeRequest{} }
func (m *CancelRemoveStakeRequest) String() string { return proto.CompactTextString(m) }
func (*CancelRemoveStakeRequest) ProtoMessage()    {}
func (*CancelRemoveStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{17}
}
func (m *CancelRemoveStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CancelRemoveStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CancelRemoveStakeRequest.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 *CancelRemoveStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelRemoveStakeRequest.Merge(m, src)
}
func (m *CancelRemoveStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *CancelRemoveStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelRemoveStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CancelRemoveStakeRequest proto.InternalMessageInfo

func (m *CancelRemoveStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *CancelRemoveStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type CancelRemoveStakeResponse struct {
}

func (m *CancelRemoveStakeResponse) Reset()         { *m = CancelRemoveStakeResponse{} }
func (m *CancelRemoveStakeResponse) String() string { return proto.CompactTextString(m) }
func (*CancelRemoveStakeResponse) ProtoMessage()    {}
func (*CancelRemoveStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{18}
}
func (m *CancelRemoveStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CancelRemoveStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CancelRemoveStakeResponse.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 *CancelRemoveStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelRemoveStakeResponse.Merge(m, src)
}
func (m *CancelRemoveStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *CancelRemoveStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelRemoveStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CancelRemoveStakeResponse proto.InternalMessageInfo

type DelegateStakeRequest struct {
	Sender  string                `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64                `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string                `protobuf:"bytes,3,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func (m *DelegateStakeRequest) Reset()         { *m = DelegateStakeRequest{} }
func (m *DelegateStakeRequest) String() string { return proto.CompactTextString(m) }
func (*DelegateStakeRequest) ProtoMessage()    {}
func (*DelegateStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{19}
}
func (m *DelegateStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegateStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegateStakeRequest.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 *DelegateStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegateStakeRequest.Merge(m, src)
}
func (m *DelegateStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *DelegateStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegateStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DelegateStakeRequest proto.InternalMessageInfo

func (m *DelegateStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *DelegateStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *DelegateStakeRequest) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type DelegateStakeResponse struct {
}

func (m *DelegateStakeResponse) Reset()         { *m = DelegateStakeResponse{} }
func (m *DelegateStakeResponse) String() string { return proto.CompactTextString(m) }
func (*DelegateStakeResponse) ProtoMessage()    {}
func (*DelegateStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{20}
}
func (m *DelegateStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegateStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegateStakeResponse.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 *DelegateStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegateStakeResponse.Merge(m, src)
}
func (m *DelegateStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *DelegateStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegateStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DelegateStakeResponse proto.InternalMessageInfo

type RemoveDelegateStakeRequest struct {
	Sender  string                `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Reputer string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	TopicId uint64                `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func (m *RemoveDelegateStakeRequest) Reset()         { *m = RemoveDelegateStakeRequest{} }
func (m *RemoveDelegateStakeRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveDelegateStakeRequest) ProtoMessage()    {}
func (*RemoveDelegateStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{21}
}
func (m *RemoveDelegateStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveDelegateStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveDelegateStakeRequest.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 *RemoveDelegateStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveDelegateStakeRequest.Merge(m, src)
}
func (m *RemoveDelegateStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveDelegateStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveDelegateStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveDelegateStakeRequest proto.InternalMessageInfo

func (m *RemoveDelegateStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveDelegateStakeRequest) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *RemoveDelegateStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type RemoveDelegateStakeResponse struct {
}

func (m *RemoveDelegateStakeResponse) Reset()         { *m = RemoveDelegateStakeResponse{} }
func (m *RemoveDelegateStakeResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveDelegateStakeResponse) ProtoMessage()    {}
func (*RemoveDelegateStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{22}
}
func (m *RemoveDelegateStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveDelegateStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveDelegateStakeResponse.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 *RemoveDelegateStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveDelegateStakeResponse.Merge(m, src)
}
func (m *RemoveDelegateStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveDelegateStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveDelegateStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveDelegateStakeResponse proto.InternalMessageInfo

type CancelRemoveDelegateStakeRequest struct {
	Sender    string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId   uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Delegator string `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Reputer   string `protobuf:"bytes,4,opt,name=reputer,proto3" json:"reputer,omitempty"`
}

func (m *CancelRemoveDelegateStakeRequest) Reset()         { *m = CancelRemoveDelegateStakeRequest{} }
func (m *CancelRemoveDelegateStakeRequest) String() string { return proto.CompactTextString(m) }
func (*CancelRemoveDelegateStakeRequest) ProtoMessage()    {}
func (*CancelRemoveDelegateStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{23}
}
func (m *CancelRemoveDelegateStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CancelRemoveDelegateStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CancelRemoveDelegateStakeRequest.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 *CancelRemoveDelegateStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelRemoveDelegateStakeRequest.Merge(m, src)
}
func (m *CancelRemoveDelegateStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *CancelRemoveDelegateStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelRemoveDelegateStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CancelRemoveDelegateStakeRequest proto.InternalMessageInfo

func (m *CancelRemoveDelegateStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *CancelRemoveDelegateStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *CancelRemoveDelegateStakeRequest) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *CancelRemoveDelegateStakeRequest) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type CancelRemoveDelegateStakeResponse struct {
}

func (m *CancelRemoveDelegateStakeResponse) Reset()         { *m = CancelRemoveDelegateStakeResponse{} }
func (m *CancelRemoveDelegateStakeResponse) String() string { return proto.CompactTextString(m) }
func (*CancelRemoveDelegateStakeResponse) ProtoMessage()    {}
func (*CancelRemoveDelegateStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{24}
}
func (m *CancelRemoveDelegateStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CancelRemoveDelegateStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CancelRemoveDelegateStakeResponse.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 *CancelRemoveDelegateStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelRemoveDelegateStakeResponse.Merge(m, src)
}
func (m *CancelRemoveDelegateStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *CancelRemoveDelegateStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelRemoveDelegateStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CancelRemoveDelegateStakeResponse proto.InternalMessageInfo

type RewardDelegateStakeRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string `protobuf:"bytes,3,opt,name=reputer,proto3" json:"reputer,omitempty"`
}

func (m *RewardDelegateStakeRequest) Reset()         { *m = RewardDelegateStakeRequest{} }
func (m *RewardDelegateStakeRequest) String() string { return proto.CompactTextString(m) }
func (*RewardDelegateStakeRequest) ProtoMessage()    {}
func (*RewardDelegateStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{25}
}
func (m *RewardDelegateStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RewardDelegateStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RewardDelegateStakeRequest.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 *RewardDelegateStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RewardDelegateStakeRequest.Merge(m, src)
}
func (m *RewardDelegateStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RewardDelegateStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RewardDelegateStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RewardDelegateStakeRequest proto.InternalMessageInfo

func (m *RewardDelegateStakeRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RewardDelegateStakeRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *RewardDelegateStakeRequest) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type RewardDelegateStakeResponse struct {
}

func (m *RewardDelegateStakeResponse) Reset()         { *m = RewardDelegateStakeResponse{} }
func (m *RewardDelegateStakeResponse) String() string { return proto.CompactTextString(m) }
func (*RewardDelegateStakeResponse) ProtoMessage()    {}
func (*RewardDelegateStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{26}
}
func (m *RewardDelegateStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RewardDelegateStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RewardDelegateStakeResponse.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 *RewardDelegateStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RewardDelegateStakeResponse.Merge(m, src)
}
func (m *RewardDelegateStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RewardDelegateStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RewardDelegateStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RewardDelegateStakeResponse proto.InternalMessageInfo

// Inferences are requested by consumers who fund topics by sending ALLO to
// ecosystem account via TopicFund messages
type FundTopicRequest struct {
	Sender  string                `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64                `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

func (m *FundTopicRequest) Reset()         { *m = FundTopicRequest{} }
func (m *FundTopicRequest) String() string { return proto.CompactTextString(m) }
func (*FundTopicRequest) ProtoMessage()    {}
func (*FundTopicRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{27}
}
func (m *FundTopicRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FundTopicRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FundTopicRequest.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 *FundTopicRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FundTopicRequest.Merge(m, src)
}
func (m *FundTopicRequest) XXX_Size() int {
	return m.Size()
}
func (m *FundTopicRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FundTopicRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FundTopicRequest proto.InternalMessageInfo

func (m *FundTopicRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *FundTopicRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type FundTopicResponse struct {
}

func (m *FundTopicResponse) Reset()         { *m = FundTopicResponse{} }
func (m *FundTopicResponse) String() string { return proto.CompactTextString(m) }
func (*FundTopicResponse) ProtoMessage()    {}
func (*FundTopicResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{28}
}
func (m *FundTopicResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FundTopicResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FundTopicResponse.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 *FundTopicResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FundTopicResponse.Merge(m, src)
}
func (m *FundTopicResponse) XXX_Size() int {
	return m.Size()
}
func (m *FundTopicResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FundTopicResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FundTopicResponse proto.InternalMessageInfo

type AddToWhitelistAdminRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToWhitelistAdminRequest) Reset()         { *m = AddToWhitelistAdminRequest{} }
func (m *AddToWhitelistAdminRequest) String() string { return proto.CompactTextString(m) }
func (*AddToWhitelistAdminRequest) ProtoMessage()    {}
func (*AddToWhitelistAdminRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{29}
}
func (m *AddToWhitelistAdminRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToWhitelistAdminRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToWhitelistAdminRequest.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 *AddToWhitelistAdminRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToWhitelistAdminRequest.Merge(m, src)
}
func (m *AddToWhitelistAdminRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToWhitelistAdminRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToWhitelistAdminRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToWhitelistAdminRequest proto.InternalMessageInfo

func (m *AddToWhitelistAdminRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToWhitelistAdminRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToWhitelistAdminResponse struct {
}

func (m *AddToWhitelistAdminResponse) Reset()         { *m = AddToWhitelistAdminResponse{} }
func (m *AddToWhitelistAdminResponse) String() string { return proto.CompactTextString(m) }
func (*AddToWhitelistAdminResponse) ProtoMessage()    {}
func (*AddToWhitelistAdminResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{30}
}
func (m *AddToWhitelistAdminResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToWhitelistAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToWhitelistAdminResponse.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 *AddToWhitelistAdminResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToWhitelistAdminResponse.Merge(m, src)
}
func (m *AddToWhitelistAdminResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToWhitelistAdminResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToWhitelistAdminResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToWhitelistAdminResponse proto.InternalMessageInfo

type RemoveFromWhitelistAdminRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromWhitelistAdminRequest) Reset()         { *m = RemoveFromWhitelistAdminRequest{} }
func (m *RemoveFromWhitelistAdminRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromWhitelistAdminRequest) ProtoMessage()    {}
func (*RemoveFromWhitelistAdminRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{31}
}
func (m *RemoveFromWhitelistAdminRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromWhitelistAdminRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromWhitelistAdminRequest.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 *RemoveFromWhitelistAdminRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromWhitelistAdminRequest.Merge(m, src)
}
func (m *RemoveFromWhitelistAdminRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromWhitelistAdminRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromWhitelistAdminRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromWhitelistAdminRequest proto.InternalMessageInfo

func (m *RemoveFromWhitelistAdminRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromWhitelistAdminRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromWhitelistAdminResponse struct {
}

func (m *RemoveFromWhitelistAdminResponse) Reset()         { *m = RemoveFromWhitelistAdminResponse{} }
func (m *RemoveFromWhitelistAdminResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromWhitelistAdminResponse) ProtoMessage()    {}
func (*RemoveFromWhitelistAdminResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{32}
}
func (m *RemoveFromWhitelistAdminResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromWhitelistAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromWhitelistAdminResponse.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 *RemoveFromWhitelistAdminResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromWhitelistAdminResponse.Merge(m, src)
}
func (m *RemoveFromWhitelistAdminResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromWhitelistAdminResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromWhitelistAdminResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromWhitelistAdminResponse proto.InternalMessageInfo

type EnableTopicWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *EnableTopicWorkerWhitelistRequest) Reset()         { *m = EnableTopicWorkerWhitelistRequest{} }
func (m *EnableTopicWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*EnableTopicWorkerWhitelistRequest) ProtoMessage()    {}
func (*EnableTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{33}
}
func (m *EnableTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnableTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnableTopicWorkerWhitelistRequest.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 *EnableTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnableTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *EnableTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *EnableTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EnableTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EnableTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *EnableTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *EnableTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EnableTopicWorkerWhitelistResponse struct {
}

func (m *EnableTopicWorkerWhitelistResponse) Reset()         { *m = EnableTopicWorkerWhitelistResponse{} }
func (m *EnableTopicWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*EnableTopicWorkerWhitelistResponse) ProtoMessage()    {}
func (*EnableTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{34}
}
func (m *EnableTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnableTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnableTopicWorkerWhitelistResponse.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 *EnableTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnableTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *EnableTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *EnableTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EnableTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EnableTopicWorkerWhitelistResponse proto.InternalMessageInfo

type DisableTopicWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *DisableTopicWorkerWhitelistRequest) Reset()         { *m = DisableTopicWorkerWhitelistRequest{} }
func (m *DisableTopicWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*DisableTopicWorkerWhitelistRequest) ProtoMessage()    {}
func (*DisableTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{35}
}
func (m *DisableTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisableTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisableTopicWorkerWhitelistRequest.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 *DisableTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisableTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *DisableTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *DisableTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DisableTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DisableTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *DisableTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *DisableTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type DisableTopicWorkerWhitelistResponse struct {
}

func (m *DisableTopicWorkerWhitelistResponse) Reset()         { *m = DisableTopicWorkerWhitelistResponse{} }
func (m *DisableTopicWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*DisableTopicWorkerWhitelistResponse) ProtoMessage()    {}
func (*DisableTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{36}
}
func (m *DisableTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisableTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisableTopicWorkerWhitelistResponse.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 *DisableTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisableTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *DisableTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *DisableTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DisableTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DisableTopicWorkerWhitelistResponse proto.InternalMessageInfo

type EnableTopicReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *EnableTopicReputerWhitelistRequest) Reset()         { *m = EnableTopicReputerWhitelistRequest{} }
func (m *EnableTopicReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*EnableTopicReputerWhitelistRequest) ProtoMessage()    {}
func (*EnableTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{37}
}
func (m *EnableTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnableTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnableTopicReputerWhitelistRequest.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 *EnableTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnableTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *EnableTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *EnableTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EnableTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EnableTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *EnableTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *EnableTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EnableTopicReputerWhitelistResponse struct {
}

func (m *EnableTopicReputerWhitelistResponse) Reset()         { *m = EnableTopicReputerWhitelistResponse{} }
func (m *EnableTopicReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*EnableTopicReputerWhitelistResponse) ProtoMessage()    {}
func (*EnableTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{38}
}
func (m *EnableTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnableTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnableTopicReputerWhitelistResponse.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 *EnableTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnableTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *EnableTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *EnableTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EnableTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EnableTopicReputerWhitelistResponse proto.InternalMessageInfo

type DisableTopicReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TopicId uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *DisableTopicReputerWhitelistRequest) Reset()         { *m = DisableTopicReputerWhitelistRequest{} }
func (m *DisableTopicReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*DisableTopicReputerWhitelistRequest) ProtoMessage()    {}
func (*DisableTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{39}
}
func (m *DisableTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisableTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisableTopicReputerWhitelistRequest.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 *DisableTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisableTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *DisableTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *DisableTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DisableTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DisableTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *DisableTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *DisableTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type DisableTopicReputerWhitelistResponse struct {
}

func (m *DisableTopicReputerWhitelistResponse) Reset()         { *m = DisableTopicReputerWhitelistResponse{} }
func (m *DisableTopicReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*DisableTopicReputerWhitelistResponse) ProtoMessage()    {}
func (*DisableTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{40}
}
func (m *DisableTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisableTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisableTopicReputerWhitelistResponse.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 *DisableTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisableTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *DisableTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *DisableTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DisableTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DisableTopicReputerWhitelistResponse proto.InternalMessageInfo

type AddToGlobalWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToGlobalWhitelistRequest) Reset()         { *m = AddToGlobalWhitelistRequest{} }
func (m *AddToGlobalWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalWhitelistRequest) ProtoMessage()    {}
func (*AddToGlobalWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{41}
}
func (m *AddToGlobalWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalWhitelistRequest.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 *AddToGlobalWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalWhitelistRequest.Merge(m, src)
}
func (m *AddToGlobalWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalWhitelistRequest proto.InternalMessageInfo

func (m *AddToGlobalWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToGlobalWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToGlobalWhitelistResponse struct {
}

func (m *AddToGlobalWhitelistResponse) Reset()         { *m = AddToGlobalWhitelistResponse{} }
func (m *AddToGlobalWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalWhitelistResponse) ProtoMessage()    {}
func (*AddToGlobalWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{42}
}
func (m *AddToGlobalWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalWhitelistResponse.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 *AddToGlobalWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalWhitelistResponse.Merge(m, src)
}
func (m *AddToGlobalWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalWhitelistResponse proto.InternalMessageInfo

type RemoveFromGlobalWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromGlobalWhitelistRequest) Reset()         { *m = RemoveFromGlobalWhitelistRequest{} }
func (m *RemoveFromGlobalWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromGlobalWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{43}
}
func (m *RemoveFromGlobalWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalWhitelistRequest.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 *RemoveFromGlobalWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromGlobalWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromGlobalWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromGlobalWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromGlobalWhitelistResponse struct {
}

func (m *RemoveFromGlobalWhitelistResponse) Reset()         { *m = RemoveFromGlobalWhitelistResponse{} }
func (m *RemoveFromGlobalWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromGlobalWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{44}
}
func (m *RemoveFromGlobalWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalWhitelistResponse.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 *RemoveFromGlobalWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromGlobalWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalWhitelistResponse proto.InternalMessageInfo

type AddToTopicCreatorWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToTopicCreatorWhitelistRequest) Reset()         { *m = AddToTopicCreatorWhitelistRequest{} }
func (m *AddToTopicCreatorWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToTopicCreatorWhitelistRequest) ProtoMessage()    {}
func (*AddToTopicCreatorWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{45}
}
func (m *AddToTopicCreatorWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicCreatorWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicCreatorWhitelistRequest.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 *AddToTopicCreatorWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicCreatorWhitelistRequest.Merge(m, src)
}
func (m *AddToTopicCreatorWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicCreatorWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicCreatorWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicCreatorWhitelistRequest proto.InternalMessageInfo

func (m *AddToTopicCreatorWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToTopicCreatorWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToTopicCreatorWhitelistResponse struct {
}

func (m *AddToTopicCreatorWhitelistResponse) Reset()         { *m = AddToTopicCreatorWhitelistResponse{} }
func (m *AddToTopicCreatorWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToTopicCreatorWhitelistResponse) ProtoMessage()    {}
func (*AddToTopicCreatorWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{46}
}
func (m *AddToTopicCreatorWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicCreatorWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicCreatorWhitelistResponse.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 *AddToTopicCreatorWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicCreatorWhitelistResponse.Merge(m, src)
}
func (m *AddToTopicCreatorWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicCreatorWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicCreatorWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicCreatorWhitelistResponse proto.InternalMessageInfo

type AddToGlobalWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToGlobalWorkerWhitelistRequest) Reset()         { *m = AddToGlobalWorkerWhitelistRequest{} }
func (m *AddToGlobalWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalWorkerWhitelistRequest) ProtoMessage()    {}
func (*AddToGlobalWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{47}
}
func (m *AddToGlobalWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalWorkerWhitelistRequest.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 *AddToGlobalWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalWorkerWhitelistRequest.Merge(m, src)
}
func (m *AddToGlobalWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalWorkerWhitelistRequest proto.InternalMessageInfo

func (m *AddToGlobalWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToGlobalWorkerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToGlobalWorkerWhitelistResponse struct {
}

func (m *AddToGlobalWorkerWhitelistResponse) Reset()         { *m = AddToGlobalWorkerWhitelistResponse{} }
func (m *AddToGlobalWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalWorkerWhitelistResponse) ProtoMessage()    {}
func (*AddToGlobalWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{48}
}
func (m *AddToGlobalWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalWorkerWhitelistResponse.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 *AddToGlobalWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalWorkerWhitelistResponse.Merge(m, src)
}
func (m *AddToGlobalWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalWorkerWhitelistResponse proto.InternalMessageInfo

type RemoveFromGlobalWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromGlobalWorkerWhitelistRequest) Reset() {
	*m = RemoveFromGlobalWorkerWhitelistRequest{}
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalWorkerWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromGlobalWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{49}
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalWorkerWhitelistRequest.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 *RemoveFromGlobalWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalWorkerWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalWorkerWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromGlobalWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromGlobalWorkerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromGlobalWorkerWhitelistResponse struct {
}

func (m *RemoveFromGlobalWorkerWhitelistResponse) Reset() {
	*m = RemoveFromGlobalWorkerWhitelistResponse{}
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalWorkerWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromGlobalWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{50}
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalWorkerWhitelistResponse.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 *RemoveFromGlobalWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalWorkerWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalWorkerWhitelistResponse proto.InternalMessageInfo

type AddToGlobalReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToGlobalReputerWhitelistRequest) Reset()         { *m = AddToGlobalReputerWhitelistRequest{} }
func (m *AddToGlobalReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalReputerWhitelistRequest) ProtoMessage()    {}
func (*AddToGlobalReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{51}
}
func (m *AddToGlobalReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalReputerWhitelistRequest.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 *AddToGlobalReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalReputerWhitelistRequest.Merge(m, src)
}
func (m *AddToGlobalReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalReputerWhitelistRequest proto.InternalMessageInfo

func (m *AddToGlobalReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToGlobalReputerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToGlobalReputerWhitelistResponse struct {
}

func (m *AddToGlobalReputerWhitelistResponse) Reset()         { *m = AddToGlobalReputerWhitelistResponse{} }
func (m *AddToGlobalReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalReputerWhitelistResponse) ProtoMessage()    {}
func (*AddToGlobalReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{52}
}
func (m *AddToGlobalReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalReputerWhitelistResponse.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 *AddToGlobalReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalReputerWhitelistResponse.Merge(m, src)
}
func (m *AddToGlobalReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalReputerWhitelistResponse proto.InternalMessageInfo

type RemoveFromGlobalReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromGlobalReputerWhitelistRequest) Reset() {
	*m = RemoveFromGlobalReputerWhitelistRequest{}
}
func (m *RemoveFromGlobalReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalReputerWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromGlobalReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{53}
}
func (m *RemoveFromGlobalReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalReputerWhitelistRequest.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 *RemoveFromGlobalReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalReputerWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromGlobalReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalReputerWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromGlobalReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromGlobalReputerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromGlobalReputerWhitelistResponse struct {
}

func (m *RemoveFromGlobalReputerWhitelistResponse) Reset() {
	*m = RemoveFromGlobalReputerWhitelistResponse{}
}
func (m *RemoveFromGlobalReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalReputerWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromGlobalReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{54}
}
func (m *RemoveFromGlobalReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalReputerWhitelistResponse.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 *RemoveFromGlobalReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalReputerWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromGlobalReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalReputerWhitelistResponse proto.InternalMessageInfo

type AddToGlobalAdminWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *AddToGlobalAdminWhitelistRequest) Reset()         { *m = AddToGlobalAdminWhitelistRequest{} }
func (m *AddToGlobalAdminWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalAdminWhitelistRequest) ProtoMessage()    {}
func (*AddToGlobalAdminWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{55}
}
func (m *AddToGlobalAdminWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalAdminWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalAdminWhitelistRequest.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 *AddToGlobalAdminWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalAdminWhitelistRequest.Merge(m, src)
}
func (m *AddToGlobalAdminWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalAdminWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalAdminWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalAdminWhitelistRequest proto.InternalMessageInfo

func (m *AddToGlobalAdminWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToGlobalAdminWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type AddToGlobalAdminWhitelistResponse struct {
}

func (m *AddToGlobalAdminWhitelistResponse) Reset()         { *m = AddToGlobalAdminWhitelistResponse{} }
func (m *AddToGlobalAdminWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToGlobalAdminWhitelistResponse) ProtoMessage()    {}
func (*AddToGlobalAdminWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{56}
}
func (m *AddToGlobalAdminWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToGlobalAdminWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToGlobalAdminWhitelistResponse.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 *AddToGlobalAdminWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToGlobalAdminWhitelistResponse.Merge(m, src)
}
func (m *AddToGlobalAdminWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToGlobalAdminWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToGlobalAdminWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToGlobalAdminWhitelistResponse proto.InternalMessageInfo

type RemoveFromGlobalAdminWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromGlobalAdminWhitelistRequest) Reset()         { *m = RemoveFromGlobalAdminWhitelistRequest{} }
func (m *RemoveFromGlobalAdminWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalAdminWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromGlobalAdminWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{57}
}
func (m *RemoveFromGlobalAdminWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalAdminWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalAdminWhitelistRequest.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 *RemoveFromGlobalAdminWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalAdminWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromGlobalAdminWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalAdminWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalAdminWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalAdminWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromGlobalAdminWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromGlobalAdminWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromGlobalAdminWhitelistResponse struct {
}

func (m *RemoveFromGlobalAdminWhitelistResponse) Reset() {
	*m = RemoveFromGlobalAdminWhitelistResponse{}
}
func (m *RemoveFromGlobalAdminWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromGlobalAdminWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromGlobalAdminWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{58}
}
func (m *RemoveFromGlobalAdminWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromGlobalAdminWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromGlobalAdminWhitelistResponse.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 *RemoveFromGlobalAdminWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromGlobalAdminWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromGlobalAdminWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromGlobalAdminWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromGlobalAdminWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromGlobalAdminWhitelistResponse proto.InternalMessageInfo

type BulkAddToGlobalWorkerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

func (m *BulkAddToGlobalWorkerWhitelistRequest) Reset()         { *m = BulkAddToGlobalWorkerWhitelistRequest{} }
func (m *BulkAddToGlobalWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*BulkAddToGlobalWorkerWhitelistRequest) ProtoMessage()    {}
func (*BulkAddToGlobalWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{59}
}
func (m *BulkAddToGlobalWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToGlobalWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToGlobalWorkerWhitelistRequest.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 *BulkAddToGlobalWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToGlobalWorkerWhitelistRequest.Merge(m, src)
}
func (m *BulkAddToGlobalWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToGlobalWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToGlobalWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToGlobalWorkerWhitelistRequest proto.InternalMessageInfo

func (m *BulkAddToGlobalWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkAddToGlobalWorkerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type BulkAddToGlobalWorkerWhitelistResponse struct {
}

func (m *BulkAddToGlobalWorkerWhitelistResponse) Reset() {
	*m = BulkAddToGlobalWorkerWhitelistResponse{}
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*BulkAddToGlobalWorkerWhitelistResponse) ProtoMessage()    {}
func (*BulkAddToGlobalWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{60}
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToGlobalWorkerWhitelistResponse.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 *BulkAddToGlobalWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToGlobalWorkerWhitelistResponse.Merge(m, src)
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToGlobalWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToGlobalWorkerWhitelistResponse proto.InternalMessageInfo

type BulkRemoveFromGlobalWorkerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) Reset() {
	*m = BulkRemoveFromGlobalWorkerWhitelistRequest{}
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromGlobalWorkerWhitelistRequest) ProtoMessage() {}
func (*BulkRemoveFromGlobalWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{61}
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistRequest.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 *BulkRemoveFromGlobalWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistRequest.Merge(m, src)
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistRequest proto.InternalMessageInfo

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type BulkRemoveFromGlobalWorkerWhitelistResponse struct {
}

func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) Reset() {
	*m = BulkRemoveFromGlobalWorkerWhitelistResponse{}
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromGlobalWorkerWhitelistResponse) ProtoMessage() {}
func (*BulkRemoveFromGlobalWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{62}
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistResponse.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 *BulkRemoveFromGlobalWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistResponse.Merge(m, src)
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromGlobalWorkerWhitelistResponse proto.InternalMessageInfo

type BulkAddToGlobalReputerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

func (m *BulkAddToGlobalReputerWhitelistRequest) Reset() {
	*m = BulkAddToGlobalReputerWhitelistRequest{}
}
func (m *BulkAddToGlobalReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*BulkAddToGlobalReputerWhitelistRequest) ProtoMessage()    {}
func (*BulkAddToGlobalReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{63}
}
func (m *BulkAddToGlobalReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToGlobalReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToGlobalReputerWhitelistRequest.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 *BulkAddToGlobalReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToGlobalReputerWhitelistRequest.Merge(m, src)
}
func (m *BulkAddToGlobalReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToGlobalReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToGlobalReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToGlobalReputerWhitelistRequest proto.InternalMessageInfo

func (m *BulkAddToGlobalReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkAddToGlobalReputerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type BulkAddToGlobalReputerWhitelistResponse struct {
}

func (m *BulkAddToGlobalReputerWhitelistResponse) Reset() {
	*m = BulkAddToGlobalReputerWhitelistResponse{}
}
func (m *BulkAddToGlobalReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*BulkAddToGlobalReputerWhitelistResponse) ProtoMessage()    {}
func (*BulkAddToGlobalReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{64}
}
func (m *BulkAddToGlobalReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToGlobalReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToGlobalReputerWhitelistResponse.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 *BulkAddToGlobalReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToGlobalReputerWhitelistResponse.Merge(m, src)
}
func (m *BulkAddToGlobalReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToGlobalReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToGlobalReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToGlobalReputerWhitelistResponse proto.InternalMessageInfo

type BulkRemoveFromGlobalReputerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) Reset() {
	*m = BulkRemoveFromGlobalReputerWhitelistRequest{}
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromGlobalReputerWhitelistRequest) ProtoMessage() {}
func (*BulkRemoveFromGlobalReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{65}
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistRequest.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 *BulkRemoveFromGlobalReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistRequest.Merge(m, src)
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistRequest proto.InternalMessageInfo

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type BulkRemoveFromGlobalReputerWhitelistResponse struct {
}

func (m *BulkRemoveFromGlobalReputerWhitelistResponse) Reset() {
	*m = BulkRemoveFromGlobalReputerWhitelistResponse{}
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromGlobalReputerWhitelistResponse) ProtoMessage() {}
func (*BulkRemoveFromGlobalReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{66}
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistResponse.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 *BulkRemoveFromGlobalReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistResponse.Merge(m, src)
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromGlobalReputerWhitelistResponse proto.InternalMessageInfo

type BulkAddToTopicWorkerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	TopicId   uint64   `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *BulkAddToTopicWorkerWhitelistRequest) Reset()         { *m = BulkAddToTopicWorkerWhitelistRequest{} }
func (m *BulkAddToTopicWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*BulkAddToTopicWorkerWhitelistRequest) ProtoMessage()    {}
func (*BulkAddToTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{67}
}
func (m *BulkAddToTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToTopicWorkerWhitelistRequest.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 *BulkAddToTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *BulkAddToTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *BulkAddToTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkAddToTopicWorkerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *BulkAddToTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type BulkAddToTopicWorkerWhitelistResponse struct {
}

func (m *BulkAddToTopicWorkerWhitelistResponse) Reset()         { *m = BulkAddToTopicWorkerWhitelistResponse{} }
func (m *BulkAddToTopicWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*BulkAddToTopicWorkerWhitelistResponse) ProtoMessage()    {}
func (*BulkAddToTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{68}
}
func (m *BulkAddToTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToTopicWorkerWhitelistResponse.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 *BulkAddToTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *BulkAddToTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToTopicWorkerWhitelistResponse proto.InternalMessageInfo

type BulkRemoveFromTopicWorkerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	TopicId   uint64   `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) Reset() {
	*m = BulkRemoveFromTopicWorkerWhitelistRequest{}
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromTopicWorkerWhitelistRequest) ProtoMessage() {}
func (*BulkRemoveFromTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{69}
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistRequest.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 *BulkRemoveFromTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type BulkRemoveFromTopicWorkerWhitelistResponse struct {
}

func (m *BulkRemoveFromTopicWorkerWhitelistResponse) Reset() {
	*m = BulkRemoveFromTopicWorkerWhitelistResponse{}
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromTopicWorkerWhitelistResponse) ProtoMessage() {}
func (*BulkRemoveFromTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{70}
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistResponse.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 *BulkRemoveFromTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromTopicWorkerWhitelistResponse proto.InternalMessageInfo

type BulkAddToTopicReputerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	TopicId   uint64   `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *BulkAddToTopicReputerWhitelistRequest) Reset()         { *m = BulkAddToTopicReputerWhitelistRequest{} }
func (m *BulkAddToTopicReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*BulkAddToTopicReputerWhitelistRequest) ProtoMessage()    {}
func (*BulkAddToTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{71}
}
func (m *BulkAddToTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToTopicReputerWhitelistRequest.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 *BulkAddToTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *BulkAddToTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *BulkAddToTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkAddToTopicReputerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *BulkAddToTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type BulkAddToTopicReputerWhitelistResponse struct {
}

func (m *BulkAddToTopicReputerWhitelistResponse) Reset() {
	*m = BulkAddToTopicReputerWhitelistResponse{}
}
func (m *BulkAddToTopicReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*BulkAddToTopicReputerWhitelistResponse) ProtoMessage()    {}
func (*BulkAddToTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{72}
}
func (m *BulkAddToTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkAddToTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkAddToTopicReputerWhitelistResponse.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 *BulkAddToTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkAddToTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *BulkAddToTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkAddToTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkAddToTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkAddToTopicReputerWhitelistResponse proto.InternalMessageInfo

type BulkRemoveFromTopicReputerWhitelistRequest struct {
	Sender    string   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	TopicId   uint64   `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) Reset() {
	*m = BulkRemoveFromTopicReputerWhitelistRequest{}
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromTopicReputerWhitelistRequest) ProtoMessage() {}
func (*BulkRemoveFromTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{73}
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistRequest.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 *BulkRemoveFromTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *BulkRemoveFromTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type BulkRemoveFromTopicReputerWhitelistResponse struct {
}

func (m *BulkRemoveFromTopicReputerWhitelistResponse) Reset() {
	*m = BulkRemoveFromTopicReputerWhitelistResponse{}
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) String() string {
	return proto.CompactTextString(m)
}
func (*BulkRemoveFromTopicReputerWhitelistResponse) ProtoMessage() {}
func (*BulkRemoveFromTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{74}
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistResponse.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 *BulkRemoveFromTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BulkRemoveFromTopicReputerWhitelistResponse proto.InternalMessageInfo

type RemoveFromTopicCreatorWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *RemoveFromTopicCreatorWhitelistRequest) Reset() {
	*m = RemoveFromTopicCreatorWhitelistRequest{}
}
func (m *RemoveFromTopicCreatorWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicCreatorWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromTopicCreatorWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{75}
}
func (m *RemoveFromTopicCreatorWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicCreatorWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicCreatorWhitelistRequest.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 *RemoveFromTopicCreatorWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicCreatorWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromTopicCreatorWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicCreatorWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicCreatorWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicCreatorWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromTopicCreatorWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromTopicCreatorWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type RemoveFromTopicCreatorWhitelistResponse struct {
}

func (m *RemoveFromTopicCreatorWhitelistResponse) Reset() {
	*m = RemoveFromTopicCreatorWhitelistResponse{}
}
func (m *RemoveFromTopicCreatorWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicCreatorWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromTopicCreatorWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{76}
}
func (m *RemoveFromTopicCreatorWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicCreatorWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicCreatorWhitelistResponse.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 *RemoveFromTopicCreatorWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicCreatorWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromTopicCreatorWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicCreatorWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicCreatorWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicCreatorWhitelistResponse proto.InternalMessageInfo

type AddToTopicWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TopicId uint64 `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *AddToTopicWorkerWhitelistRequest) Reset()         { *m = AddToTopicWorkerWhitelistRequest{} }
func (m *AddToTopicWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToTopicWorkerWhitelistRequest) ProtoMessage()    {}
func (*AddToTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{77}
}
func (m *AddToTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicWorkerWhitelistRequest.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 *AddToTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *AddToTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *AddToTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToTopicWorkerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *AddToTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type AddToTopicWorkerWhitelistResponse struct {
}

func (m *AddToTopicWorkerWhitelistResponse) Reset()         { *m = AddToTopicWorkerWhitelistResponse{} }
func (m *AddToTopicWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToTopicWorkerWhitelistResponse) ProtoMessage()    {}
func (*AddToTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{78}
}
func (m *AddToTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicWorkerWhitelistResponse.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 *AddToTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *AddToTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicWorkerWhitelistResponse proto.InternalMessageInfo

type RemoveFromTopicWorkerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TopicId uint64 `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *RemoveFromTopicWorkerWhitelistRequest) Reset()         { *m = RemoveFromTopicWorkerWhitelistRequest{} }
func (m *RemoveFromTopicWorkerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicWorkerWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromTopicWorkerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{79}
}
func (m *RemoveFromTopicWorkerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicWorkerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicWorkerWhitelistRequest.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 *RemoveFromTopicWorkerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicWorkerWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromTopicWorkerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicWorkerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicWorkerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicWorkerWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromTopicWorkerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromTopicWorkerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *RemoveFromTopicWorkerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type RemoveFromTopicWorkerWhitelistResponse struct {
}

func (m *RemoveFromTopicWorkerWhitelistResponse) Reset() {
	*m = RemoveFromTopicWorkerWhitelistResponse{}
}
func (m *RemoveFromTopicWorkerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicWorkerWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromTopicWorkerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{80}
}
func (m *RemoveFromTopicWorkerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicWorkerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicWorkerWhitelistResponse.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 *RemoveFromTopicWorkerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicWorkerWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromTopicWorkerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicWorkerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicWorkerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicWorkerWhitelistResponse proto.InternalMessageInfo

type AddToTopicReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TopicId uint64 `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *AddToTopicReputerWhitelistRequest) Reset()         { *m = AddToTopicReputerWhitelistRequest{} }
func (m *AddToTopicReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*AddToTopicReputerWhitelistRequest) ProtoMessage()    {}
func (*AddToTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{81}
}
func (m *AddToTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicReputerWhitelistRequest.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 *AddToTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *AddToTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *AddToTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AddToTopicReputerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *AddToTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type AddToTopicReputerWhitelistResponse struct {
}

func (m *AddToTopicReputerWhitelistResponse) Reset()         { *m = AddToTopicReputerWhitelistResponse{} }
func (m *AddToTopicReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*AddToTopicReputerWhitelistResponse) ProtoMessage()    {}
func (*AddToTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{82}
}
func (m *AddToTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddToTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddToTopicReputerWhitelistResponse.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 *AddToTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddToTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *AddToTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddToTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddToTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddToTopicReputerWhitelistResponse proto.InternalMessageInfo

type RemoveFromTopicReputerWhitelistRequest struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TopicId uint64 `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

func (m *RemoveFromTopicReputerWhitelistRequest) Reset() {
	*m = RemoveFromTopicReputerWhitelistRequest{}
}
func (m *RemoveFromTopicReputerWhitelistRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicReputerWhitelistRequest) ProtoMessage()    {}
func (*RemoveFromTopicReputerWhitelistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{83}
}
func (m *RemoveFromTopicReputerWhitelistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicReputerWhitelistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicReputerWhitelistRequest.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 *RemoveFromTopicReputerWhitelistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicReputerWhitelistRequest.Merge(m, src)
}
func (m *RemoveFromTopicReputerWhitelistRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicReputerWhitelistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicReputerWhitelistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicReputerWhitelistRequest proto.InternalMessageInfo

func (m *RemoveFromTopicReputerWhitelistRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *RemoveFromTopicReputerWhitelistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *RemoveFromTopicReputerWhitelistRequest) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type RemoveFromTopicReputerWhitelistResponse struct {
}

func (m *RemoveFromTopicReputerWhitelistResponse) Reset() {
	*m = RemoveFromTopicReputerWhitelistResponse{}
}
func (m *RemoveFromTopicReputerWhitelistResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveFromTopicReputerWhitelistResponse) ProtoMessage()    {}
func (*RemoveFromTopicReputerWhitelistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_07a224476670d6e3, []int{84}
}
func (m *RemoveFromTopicReputerWhitelistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveFromTopicReputerWhitelistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveFromTopicReputerWhitelistResponse.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 *RemoveFromTopicReputerWhitelistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveFromTopicReputerWhitelistResponse.Merge(m, src)
}
func (m *RemoveFromTopicReputerWhitelistResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveFromTopicReputerWhitelistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveFromTopicReputerWhitelistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveFromTopicReputerWhitelistResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*OptionalParams)(nil), "emissions.v9.OptionalParams")
	proto.RegisterType((*UpdateParamsRequest)(nil), "emissions.v9.UpdateParamsRequest")
	proto.RegisterType((*UpdateParamsResponse)(nil), "emissions.v9.UpdateParamsResponse")
	proto.RegisterType((*CreateNewTopicRequest)(nil), "emissions.v9.CreateNewTopicRequest")
	proto.RegisterType((*CreateNewTopicResponse)(nil), "emissions.v9.CreateNewTopicResponse")
	proto.RegisterType((*InsertReputerPayloadRequest)(nil), "emissions.v9.InsertReputerPayloadRequest")
	proto.RegisterType((*InsertReputerPayloadResponse)(nil), "emissions.v9.InsertReputerPayloadResponse")
	proto.RegisterType((*InsertWorkerPayloadRequest)(nil), "emissions.v9.InsertWorkerPayloadRequest")
	proto.RegisterType((*InsertWorkerPayloadResponse)(nil), "emissions.v9.InsertWorkerPayloadResponse")
	proto.RegisterType((*RegisterRequest)(nil), "emissions.v9.RegisterRequest")
	proto.RegisterType((*RegisterResponse)(nil), "emissions.v9.RegisterResponse")
	proto.RegisterType((*RemoveRegistrationRequest)(nil), "emissions.v9.RemoveRegistrationRequest")
	proto.RegisterType((*RemoveRegistrationResponse)(nil), "emissions.v9.RemoveRegistrationResponse")
	proto.RegisterType((*AddStakeRequest)(nil), "emissions.v9.AddStakeRequest")
	proto.RegisterType((*AddStakeResponse)(nil), "emissions.v9.AddStakeResponse")
	proto.RegisterType((*RemoveStakeRequest)(nil), "emissions.v9.RemoveStakeRequest")
	proto.RegisterType((*RemoveStakeResponse)(nil), "emissions.v9.RemoveStakeResponse")
	proto.RegisterType((*CancelRemoveStakeRequest)(nil), "emissions.v9.CancelRemoveStakeRequest")
	proto.RegisterType((*CancelRemoveStakeResponse)(nil), "emissions.v9.CancelRemoveStakeResponse")
	proto.RegisterType((*DelegateStakeRequest)(nil), "emissions.v9.DelegateStakeRequest")
	proto.RegisterType((*DelegateStakeResponse)(nil), "emissions.v9.DelegateStakeResponse")
	proto.RegisterType((*RemoveDelegateStakeRequest)(nil), "emissions.v9.RemoveDelegateStakeRequest")
	proto.RegisterType((*RemoveDelegateStakeResponse)(nil), "emissions.v9.RemoveDelegateStakeResponse")
	proto.RegisterType((*CancelRemoveDelegateStakeRequest)(nil), "emissions.v9.CancelRemoveDelegateStakeRequest")
	proto.RegisterType((*CancelRemoveDelegateStakeResponse)(nil), "emissions.v9.CancelRemoveDelegateStakeResponse")
	proto.RegisterType((*RewardDelegateStakeRequest)(nil), "emissions.v9.RewardDelegateStakeRequest")
	proto.RegisterType((*RewardDelegateStakeResponse)(nil), "emissions.v9.RewardDelegateStakeResponse")
	proto.RegisterType((*FundTopicRequest)(nil), "emissions.v9.FundTopicRequest")
	proto.RegisterType((*FundTopicResponse)(nil), "emissions.v9.FundTopicResponse")
	proto.RegisterType((*AddToWhitelistAdminRequest)(nil), "emissions.v9.AddToWhitelistAdminRequest")
	proto.RegisterType((*AddToWhitelistAdminResponse)(nil), "emissions.v9.AddToWhitelistAdminResponse")
	proto.RegisterType((*RemoveFromWhitelistAdminRequest)(nil), "emissions.v9.RemoveFromWhitelistAdminRequest")
	proto.RegisterType((*RemoveFromWhitelistAdminResponse)(nil), "emissions.v9.RemoveFromWhitelistAdminResponse")
	proto.RegisterType((*EnableTopicWorkerWhitelistRequest)(nil), "emissions.v9.EnableTopicWorkerWhitelistRequest")
	proto.RegisterType((*EnableTopicWorkerWhitelistResponse)(nil), "emissions.v9.EnableTopicWorkerWhitelistResponse")
	proto.RegisterType((*DisableTopicWorkerWhitelistRequest)(nil), "emissions.v9.DisableTopicWorkerWhitelistRequest")
	proto.RegisterType((*DisableTopicWorkerWhitelistResponse)(nil), "emissions.v9.DisableTopicWorkerWhitelistResponse")
	proto.RegisterType((*EnableTopicReputerWhitelistRequest)(nil), "emissions.v9.EnableTopicReputerWhitelistRequest")
	proto.RegisterType((*EnableTopicReputerWhitelistResponse)(nil), "emissions.v9.EnableTopicReputerWhitelistResponse")
	proto.RegisterType((*DisableTopicReputerWhitelistRequest)(nil), "emissions.v9.DisableTopicReputerWhitelistRequest")
	proto.RegisterType((*DisableTopicReputerWhitelistResponse)(nil), "emissions.v9.DisableTopicReputerWhitelistResponse")
	proto.RegisterType((*AddToGlobalWhitelistRequest)(nil), "emissions.v9.AddToGlobalWhitelistRequest")
	proto.RegisterType((*AddToGlobalWhitelistResponse)(nil), "emissions.v9.AddToGlobalWhitelistResponse")
	proto.RegisterType((*RemoveFromGlobalWhitelistRequest)(nil), "emissions.v9.RemoveFromGlobalWhitelistRequest")
	proto.RegisterType((*RemoveFromGlobalWhitelistResponse)(nil), "emissions.v9.RemoveFromGlobalWhitelistResponse")
	proto.RegisterType((*AddToTopicCreatorWhitelistRequest)(nil), "emissions.v9.AddToTopicCreatorWhitelistRequest")
	proto.RegisterType((*AddToTopicCreatorWhitelistResponse)(nil), "emissions.v9.AddToTopicCreatorWhitelistResponse")
	proto.RegisterType((*AddToGlobalWorkerWhitelistRequest)(nil), "emissions.v9.AddToGlobalWorkerWhitelistRequest")
	proto.RegisterType((*AddToGlobalWorkerWhitelistResponse)(nil), "emissions.v9.AddToGlobalWorkerWhitelistResponse")
	proto.RegisterType((*RemoveFromGlobalWorkerWhitelistRequest)(nil), "emissions.v9.RemoveFromGlobalWorkerWhitelistRequest")
	proto.RegisterType((*RemoveFromGlobalWorkerWhitelistResponse)(nil), "emissions.v9.RemoveFromGlobalWorkerWhitelistResponse")
	proto.RegisterType((*AddToGlobalReputerWhitelistRequest)(nil), "emissions.v9.AddToGlobalReputerWhitelistRequest")
	proto.RegisterType((*AddToGlobalReputerWhitelistResponse)(nil), "emissions.v9.AddToGlobalReputerWhitelistResponse")
	proto.RegisterType((*RemoveFromGlobalReputerWhitelistRequest)(nil), "emissions.v9.RemoveFromGlobalReputerWhitelistRequest")
	proto.RegisterType((*RemoveFromGlobalReputerWhitelistResponse)(nil), "emissions.v9.RemoveFromGlobalReputerWhitelistResponse")
	proto.RegisterType((*AddToGlobalAdminWhitelistRequest)(nil), "emissions.v9.AddToGlobalAdminWhitelistRequest")
	proto.RegisterType((*AddToGlobalAdminWhitelistResponse)(nil), "emissions.v9.AddToGlobalAdminWhitelistResponse")
	proto.RegisterType((*RemoveFromGlobalAdminWhitelistRequest)(nil), "emissions.v9.RemoveFromGlobalAdminWhitelistRequest")
	proto.RegisterType((*RemoveFromGlobalAdminWhitelistResponse)(nil), "emissions.v9.RemoveFromGlobalAdminWhitelistResponse")
	proto.RegisterType((*BulkAddToGlobalWorkerWhitelistRequest)(nil), "emissions.v9.BulkAddToGlobalWorkerWhitelistRequest")
	proto.RegisterType((*BulkAddToGlobalWorkerWhitelistResponse)(nil), "emissions.v9.BulkAddToGlobalWorkerWhitelistResponse")
	proto.RegisterType((*BulkRemoveFromGlobalWorkerWhitelistRequest)(nil), "emissions.v9.BulkRemoveFromGlobalWorkerWhitelistRequest")
	proto.RegisterType((*BulkRemoveFromGlobalWorkerWhitelistResponse)(nil), "emissions.v9.BulkRemoveFromGlobalWorkerWhitelistResponse")
	proto.RegisterType((*BulkAddToGlobalReputerWhitelistRequest)(nil), "emissions.v9.BulkAddToGlobalReputerWhitelistRequest")
	proto.RegisterType((*BulkAddToGlobalReputerWhitelistResponse)(nil), "emissions.v9.BulkAddToGlobalReputerWhitelistResponse")
	proto.RegisterType((*BulkRemoveFromGlobalReputerWhitelistRequest)(nil), "emissions.v9.BulkRemoveFromGlobalReputerWhitelistRequest")
	proto.RegisterType((*BulkRemoveFromGlobalReputerWhitelistResponse)(nil), "emissions.v9.BulkRemoveFromGlobalReputerWhitelistResponse")
	proto.RegisterType((*BulkAddToTopicWorkerWhitelistRequest)(nil), "emissions.v9.BulkAddToTopicWorkerWhitelistRequest")
	proto.RegisterType((*BulkAddToTopicWorkerWhitelistResponse)(nil), "emissions.v9.BulkAddToTopicWorkerWhitelistResponse")
	proto.RegisterType((*BulkRemoveFromTopicWorkerWhitelistRequest)(nil), "emissions.v9.BulkRemoveFromTopicWorkerWhitelistRequest")
	proto.RegisterType((*BulkRemoveFromTopicWorkerWhitelistResponse)(nil), "emissions.v9.BulkRemoveFromTopicWorkerWhitelistResponse")
	proto.RegisterType((*BulkAddToTopicReputerWhitelistRequest)(nil), "emissions.v9.BulkAddToTopicReputerWhitelistRequest")
	proto.RegisterType((*BulkAddToTopicReputerWhitelistResponse)(nil), "emissions.v9.BulkAddToTopicReputerWhitelistResponse")
	proto.RegisterType((*BulkRemoveFromTopicReputerWhitelistRequest)(nil), "emissions.v9.BulkRemoveFromTopicReputerWhitelistRequest")
	proto.RegisterType((*BulkRemoveFromTopicReputerWhitelistResponse)(nil), "emissions.v9.BulkRemoveFromTopicReputerWhitelistResponse")
	proto.RegisterType((*RemoveFromTopicCreatorWhitelistRequest)(nil), "emissions.v9.RemoveFromTopicCreatorWhitelistRequest")
	proto.RegisterType((*RemoveFromTopicCreatorWhitelistResponse)(nil), "emissions.v9.RemoveFromTopicCreatorWhitelistResponse")
	proto.RegisterType((*AddToTopicWorkerWhitelistRequest)(nil), "emissions.v9.AddToTopicWorkerWhitelistRequest")
	proto.RegisterType((*AddToTopicWorkerWhitelistResponse)(nil), "emissions.v9.AddToTopicWorkerWhitelistResponse")
	proto.RegisterType((*RemoveFromTopicWorkerWhitelistRequest)(nil), "emissions.v9.RemoveFromTopicWorkerWhitelistRequest")
	proto.RegisterType((*RemoveFromTopicWorkerWhitelistResponse)(nil), "emissions.v9.RemoveFromTopicWorkerWhitelistResponse")
	proto.RegisterType((*AddToTopicReputerWhitelistRequest)(nil), "emissions.v9.AddToTopicReputerWhitelistRequest")
	proto.RegisterType((*AddToTopicReputerWhitelistResponse)(nil), "emissions.v9.AddToTopicReputerWhitelistResponse")
	proto.RegisterType((*RemoveFromTopicReputerWhitelistRequest)(nil), "emissions.v9.RemoveFromTopicReputerWhitelistRequest")
	proto.RegisterType((*RemoveFromTopicReputerWhitelistResponse)(nil), "emissions.v9.RemoveFromTopicReputerWhitelistResponse")
}

func init() { proto.RegisterFile("emissions/v9/tx.proto", fileDescriptor_07a224476670d6e3) }

var fileDescriptor_07a224476670d6e3 = []byte{
	// 3794 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5c, 0x4b, 0x6f, 0x1c, 0x49,
	0x72, 0x56, 0x89, 0x4d, 0xb2, 0x19, 0xa4, 0xc8, 0x56, 0x8a, 0xa4, 0x8a, 0x2d, 0x3e, 0x9b, 0xa4,
	0xd4, 0xe2, 0x4a, 0x6c, 0x8d, 0x1e, 0x33, 0x92, 0x76, 0x01, 0x9b, 0x1a, 0x8a, 0x32, 0x09, 0x51,
	0xcb, 0x29, 0x72, 0x46, 0x86, 0x66, 0xe1, 0xda, 0x64, 0x57, 0xb2, 0x59, 0xcb, 0x7a, 0xf4, 0x56,
	0x55, 0xf3, 0x31, 0x58, 0x63, 0x6d, 0xc1, 0x03, 0xd8, 0x6b, 0xc0, 0xb0, 0x01, 0x03, 0x06, 0x76,
	0x6d, 0x9f, 0x7d, 0x32, 0xe6, 0x60, 0x5f, 0x0c, 0x1f, 0x7c, 0xdc, 0xe3, 0xc2, 0xbe, 0x18, 0x3e,
	0x2c, 0x8c, 0x99, 0xc3, 0xfc, 0x0d, 0x23, 0x1f, 0xd5, 0xf5, 0xe8, 0xaa, 0xea, 0x6e, 0x36, 0xe9,
	0xd9, 0xcb, 0x8c, 0x2a, 0x33, 0x32, 0xe2, 0x8b, 0xc8, 0xc8, 0x88, 0xc8, 0xc8, 0x06, 0x61, 0x82,
	0x98, 0xba, 0xeb, 0xea, 0xb6, 0xe5, 0x56, 0x8e, 0x9f, 0x55, 0xbc, 0xd3, 0xd5, 0xba, 0x63, 0x7b,
	0x36, 0x1a, 0x69, 0x0e, 0xaf, 0x1e, 0x3f, 0x2b, 0x5e, 0xc7, 0xa6, 0x6e, 0xd9, 0x15, 0xf6, 0x5f,
	0x4e, 0x50, 0xbc, 0x59, 0xb5, 0x5d, 0xd3, 0x76, 0x2b, 0xa6, 0x5b, 0xab, 0x1c, 0x7f, 0x40, 0xff,
	0x27, 0x26, 0xa6, 0xf8, 0x84, 0xca, 0xbe, 0x2a, 0xfc, 0x43, 0x4c, 0xcd, 0x45, 0x64, 0xe9, 0x56,
	0xbd, 0xe1, 0x39, 0xa4, 0xde, 0xf0, 0x88, 0x23, 0x08, 0x66, 0x5b, 0x09, 0x4e, 0x6c, 0xe7, 0xa8,
	0x39, 0x3f, 0x5e, 0xb3, 0x6b, 0x36, 0x67, 0x4c, 0xff, 0xc5, 0x47, 0x4b, 0xff, 0xbe, 0x0c, 0xa3,
	0x3f, 0xac, 0x7b, 0xba, 0x6d, 0x61, 0x63, 0x07, 0x3b, 0xd8, 0x74, 0x91, 0x0c, 0x83, 0xc7, 0xc4,
	0xa1, 0x9c, 0x64, 0x69, 0xbe, 0xaf, 0x3c, 0xa4, 0xf8, 0x9f, 0xe8, 0x19, 0x4c, 0x99, 0xf8, 0x54,
	0x75, 0x89, 0xa3, 0x63, 0x43, 0xff, 0x82, 0x68, 0xaa, 0xe9, 0xd6, 0x54, 0x83, 0x58, 0x35, 0xef,
	0x50, 0xbe, 0x3a, 0xdf, 0x57, 0xee, 0x53, 0x26, 0x4d, 0x7c, 0xba, 0xdb, 0x9c, 0xdf, 0x76, 0x6b,
	0xaf, 0xd9, 0x2c, 0xc2, 0x50, 0x30, 0x75, 0x4b, 0xf5, 0xec, 0xba, 0x5e, 0x55, 0x4f, 0x88, 0x5e,
	0x3b, 0xf4, 0xe4, 0x3e, 0xca, 0xfd, 0xc5, 0x47, 0xbf, 0xfe, 0xed, 0xdc, 0x95, 0xff, 0xf9, 0xed,
	0x5c, 0xa5, 0xa6, 0x7b, 0x87, 0x8d, 0xfd, 0xd5, 0xaa, 0x6d, 0x56, 0xb0, 0x61, 0xd8, 0x0e, 0xbe,
	0x6f, 0x11, 0xa6, 0x82, 0xff, 0x59, 0x3d, 0xc4, 0xba, 0x55, 0x31, 0xb1, 0x77, 0xb8, 0xba, 0x4e,
	0xaa, 0xca, 0xa8, 0xa9, 0x5b, 0x7b, 0x94, 0xdf, 0x5b, 0xc6, 0x0e, 0x1d, 0xc0, 0xa4, 0x43, 0x7e,
	0xda, 0xd0, 0x1d, 0x8a, 0x4b, 0xb7, 0x74, 0xb3, 0x61, 0xaa, 0xae, 0x87, 0x8f, 0x88, 0xdc, 0xcf,
	0x04, 0x3d, 0x10, 0x82, 0x26, 0xb8, 0x5d, 0x5d, 0xed, 0x68, 0x55, 0xb7, 0x39, 0xbb, 0x4d, 0xcb,
	0xfb, 0xcf, 0x7f, 0xb9, 0x0f, 0xc2, 0xe0, 0x9b, 0x96, 0xf7, 0x4f, 0xdf, 0x7e, 0xb5, 0x22, 0x29,
	0xe3, 0x3e, 0xbf, 0x6d, 0xce, 0x6e, 0x97, 0x72, 0xa3, 0x56, 0x70, 0x88, 0x69, 0x1f, 0x13, 0xce,
	0x5d, 0xd5, 0x88, 0x81, 0xcf, 0xd4, 0x13, 0xdd, 0xd2, 0xec, 0x13, 0x79, 0x80, 0x5b, 0x81, 0x13,
	0x30, 0xfa, 0x75, 0x3a, 0xfd, 0x96, 0xcd, 0xa2, 0x32, 0xb7, 0x02, 0xa9, 0xdb, 0xd5, 0x43, 0xdf,
	0x6e, 0x83, 0x6c, 0x05, 0x55, 0xe6, 0x25, 0x1d, 0x16, 0xf6, 0x7a, 0x07, 0x23, 0xfb, 0xc4, 0xc3,
	0x2a, 0xb1, 0x3c, 0xc7, 0xae, 0x9f, 0xc9, 0xf9, 0xde, 0x6c, 0x35, 0x4c, 0x99, 0xbd, 0xe4, 0xbc,
	0xd0, 0x8f, 0xe0, 0x9a, 0x41, 0xb0, 0x63, 0xe9, 0x56, 0x4d, 0x75, 0xb0, 0x47, 0xe4, 0xa1, 0xde,
	0x98, 0x8f, 0xf8, 0xdc, 0x14, 0xec, 0x11, 0x64, 0x02, 0xf5, 0x01, 0xb5, 0xe6, 0x60, 0x4d, 0x27,
	0x96, 0xa7, 0x7a, 0x87, 0x0e, 0x71, 0x0f, 0x6d, 0x43, 0x93, 0xa1, 0x37, 0x31, 0xe3, 0x26, 0x3e,
	0x7d, 0x25, 0xb8, 0xee, 0xf9, 0x4c, 0x11, 0x01, 0x44, 0x4d, 0xca, 0xb7, 0xe2, 0xc0, 0xc1, 0x55,
	0xea, 0xcb, 0xf2, 0x70, 0x6f, 0xa2, 0xe8, 0x2e, 0xb1, 0xcd, 0xdb, 0x10, 0x0c, 0xd1, 0x4b, 0x98,
	0xa3, 0x5a, 0x35, 0xac, 0x83, 0x86, 0x71, 0xa0, 0x1b, 0x06, 0xd1, 0x54, 0x7e, 0xba, 0x54, 0xea,
	0x23, 0xc4, 0xf5, 0x5c, 0xf9, 0xda, 0x7c, 0x5f, 0x39, 0xa7, 0x4c, 0x9b, 0xf8, 0xf4, 0xd3, 0x80,
	0xea, 0x2d, 0x23, 0x52, 0x04, 0x0d, 0x7a, 0x05, 0xf3, 0x71, 0x36, 0xe2, 0x14, 0x07, 0x7c, 0x46,
	0x19, 0x9f, 0x99, 0x28, 0x1f, 0x85, 0x53, 0x35, 0x19, 0x7d, 0x01, 0x33, 0xfc, 0x2c, 0x39, 0xe4,
	0x04, 0x3b, 0x9a, 0xd0, 0x5f, 0x37, 0xeb, 0xb6, 0xe3, 0x61, 0xab, 0x4a, 0xe4, 0xb1, 0xde, 0x2c,
	0x50, 0x64, 0xdc, 0x15, 0xc6, 0x9c, 0x59, 0x62, 0xb3, 0xc9, 0x1a, 0x7d, 0x29, 0xc1, 0x62, 0x44,
	0xf8, 0x01, 0x21, 0xaa, 0x43, 0x8e, 0x89, 0xd5, 0x88, 0x40, 0x28, 0xf4, 0x06, 0x61, 0x2e, 0x04,
	0x61, 0x83, 0x10, 0x85, 0x0b, 0x08, 0xe1, 0x20, 0x80, 0x22, 0x30, 0xb0, 0x51, 0x3f, 0xc4, 0xf2,
	0xf5, 0x1e, 0xb7, 0x3e, 0x24, 0x75, 0x8d, 0x32, 0x44, 0x55, 0xb8, 0xee, 0x61, 0xf7, 0x28, 0x2a,
	0x05, 0xf5, 0x26, 0x65, 0x8c, 0x72, 0x0c, 0x0b, 0xa1, 0x36, 0x3d, 0xc6, 0x86, 0xae, 0x61, 0xcf,
	0x76, 0x5c, 0xf5, 0xd8, 0x55, 0xf9, 0x42, 0xb5, 0x4e, 0x9c, 0x2a, 0x3d, 0x46, 0x5c, 0xba, 0x7c,
	0xa3, 0x47, 0x9b, 0x06, 0x32, 0x3e, 0x73, 0xd7, 0x18, 0xc9, 0x0e, 0x17, 0xc0, 0xc1, 0xa0, 0x1f,
	0xc0, 0x2d, 0x16, 0xe2, 0xb1, 0x59, 0x37, 0x88, 0xab, 0x7a, 0xb6, 0xea, 0x56, 0xb1, 0x41, 0x54,
	0xb7, 0x6a, 0x3b, 0xc4, 0x95, 0xc7, 0x99, 0x6f, 0xde, 0xa4, 0x41, 0x9e, 0x53, 0xec, 0xd9, 0xbb,
	0x74, 0x7e, 0x97, 0x4d, 0xa3, 0xe7, 0x50, 0xa4, 0xab, 0x3d, 0xbb, 0xae, 0xea, 0xd6, 0x01, 0x71,
	0x88, 0xc3, 0x58, 0x08, 0xec, 0x13, 0x6c, 0x31, 0x8d, 0x0e, 0x7b, 0x76, 0x7d, 0x53, 0xcc, 0xef,
	0xd9, 0x42, 0xf2, 0xef, 0xc3, 0x8c, 0xbf, 0xf6, 0xc0, 0x76, 0x48, 0x15, 0xbb, 0x5e, 0x74, 0xf9,
	0x24, 0x5b, 0x3e, 0xc5, 0x97, 0x6f, 0x04, 0x24, 0x4d, 0x0e, 0x21, 0xe9, 0xe2, 0x50, 0x85, 0x97,
	0xdf, 0x0c, 0x4b, 0x17, 0xc7, 0x29, 0x58, 0xfb, 0x0e, 0x0a, 0x55, 0x87, 0x60, 0x8f, 0x88, 0x14,
	0x75, 0x40, 0x88, 0x2c, 0x9f, 0x33, 0x6d, 0x8c, 0x72, 0x4e, 0x2c, 0x37, 0x6d, 0x10, 0x82, 0xbe,
	0x0f, 0xc5, 0x66, 0x34, 0xd4, 0x88, 0xcb, 0xb6, 0x93, 0x02, 0xd5, 0x29, 0x02, 0x79, 0x8a, 0x9b,
	0xd4, 0xa7, 0x58, 0xe7, 0x04, 0xdb, 0xf8, 0x74, 0x93, 0x4e, 0xa3, 0xcf, 0xa1, 0xe0, 0x90, 0x9a,
	0xee, 0x7a, 0x0e, 0xa6, 0x81, 0x88, 0x01, 0x9b, 0x3e, 0x27, 0xb0, 0xb1, 0x30, 0x27, 0x8a, 0xec,
	0x1e, 0x20, 0x8d, 0x1c, 0xe0, 0x86, 0xe1, 0xa9, 0x75, 0x5c, 0x23, 0xaa, 0xa1, 0x9b, 0xba, 0x27,
	0xcf, 0x30, 0x44, 0x05, 0x31, 0xb3, 0x83, 0x6b, 0xe4, 0x35, 0x1d, 0x47, 0x4b, 0x30, 0x4a, 0x61,
	0x87, 0x28, 0x67, 0x19, 0xe5, 0x88, 0x89, 0x4f, 0x03, 0x2a, 0xba, 0x8f, 0xb1, 0x1c, 0xa7, 0x3a,
	0xa4, 0x6a, 0x3b, 0x9a, 0x58, 0x34, 0xc7, 0x12, 0xde, 0x54, 0x34, 0xe1, 0x29, 0x8c, 0x82, 0x73,
	0x28, 0x43, 0x61, 0xdf, 0xb0, 0xab, 0x47, 0x2e, 0x75, 0x7e, 0xd5, 0xb4, 0x2d, 0xef, 0x50, 0x9e,
	0x67, 0x92, 0x46, 0xf9, 0xf8, 0x0e, 0x71, 0xb6, 0xe9, 0x28, 0x8d, 0x00, 0x75, 0xff, 0x5c, 0x72,
	0x87, 0xa3, 0x71, 0x67, 0xa1, 0xc7, 0x08, 0x50, 0xe7, 0x3e, 0xb1, 0xe9, 0x33, 0xa4, 0x11, 0xa0,
	0x29, 0xc6, 0xf7, 0x4d, 0xb9, 0xd4, 0x63, 0x04, 0x10, 0x52, 0x7c, 0x47, 0xa6, 0x15, 0x52, 0x53,
	0x88, 0x70, 0x5f, 0x79, 0xb1, 0xc7, 0x0a, 0x49, 0xc8, 0x10, 0xde, 0x4e, 0xcd, 0x55, 0x6d, 0x35,
	0xd7, 0x52, 0x8f, 0xe6, 0xaa, 0x26, 0x98, 0xab, 0xda, 0x62, 0xae, 0xe5, 0x1e, 0xcd, 0x55, 0x8d,
	0x99, 0xeb, 0x0d, 0x0c, 0x54, 0x55, 0xcb, 0x76, 0x4c, 0xf9, 0x76, 0x6f, 0x9c, 0xfb, 0xab, 0x6f,
	0x6c, 0xc7, 0x44, 0x3f, 0x86, 0x31, 0x52, 0x77, 0x75, 0xc3, 0xb6, 0x9a, 0xd6, 0x2f, 0xf7, 0x68,
	0x7d, 0xc1, 0xcf, 0xb7, 0xfe, 0x67, 0x70, 0xf7, 0x10, 0x1b, 0x07, 0xec, 0xe8, 0xd7, 0x1d, 0xbb,
	0x4a, 0x5c, 0x57, 0xa4, 0x6d, 0x56, 0x2d, 0x62, 0xc3, 0x55, 0x89, 0xa5, 0xa9, 0xcc, 0xc5, 0xe5,
	0x15, 0xe6, 0xef, 0x8b, 0x74, 0xc1, 0x36, 0x3e, 0xdd, 0xe1, 0xe4, 0x2c, 0x11, 0x2b, 0x82, 0xf8,
	0xa5, 0xa5, 0xbd, 0xa0, 0xa4, 0x34, 0x74, 0x69, 0xd8, 0xc3, 0xaa, 0x4b, 0x2c, 0x8d, 0x96, 0x74,
	0x34, 0x42, 0x7c, 0xef, 0xbc, 0xa1, 0x8b, 0x72, 0xda, 0xe5, 0x8c, 0x68, 0x80, 0xc0, 0x50, 0xf0,
	0xad, 0xe2, 0xe2, 0x03, 0xa2, 0x6a, 0xfa, 0xb1, 0x7c, 0xef, 0x62, 0xcc, 0xb2, 0x8b, 0x0f, 0xc8,
	0xba, 0x7e, 0xec, 0x5f, 0x2a, 0x88, 0x41, 0x4c, 0x62, 0x79, 0xfc, 0xcc, 0x37, 0xbd, 0xe6, 0x7e,
	0x33, 0x68, 0xbf, 0x14, 0xf3, 0x3b, 0xc4, 0x69, 0xfa, 0x80, 0x48, 0x56, 0xb4, 0x44, 0x3b, 0x16,
	0x81, 0x9b, 0xaf, 0xe7, 0x36, 0x5c, 0x6d, 0x26, 0xab, 0x35, 0x46, 0xc1, 0x02, 0x32, 0x65, 0xc0,
	0xed, 0xb6, 0x02, 0xd7, 0x59, 0xaa, 0xf3, 0x1c, 0x6a, 0x35, 0x51, 0x8d, 0x57, 0xd8, 0x9a, 0x31,
	0x9a, 0xe0, 0xd8, 0xb8, 0x28, 0xc7, 0x6d, 0xb8, 0xa9, 0x5b, 0xba, 0xa7, 0x63, 0x43, 0x75, 0x48,
	0xcd, 0x21, 0x9e, 0xfa, 0xd3, 0x06, 0xb6, 0x3c, 0xdd, 0x20, 0xf2, 0x83, 0xde, 0xcc, 0x31, 0x21,
	0xf8, 0x2a, 0x8c, 0xed, 0x27, 0x82, 0x2b, 0xfa, 0x23, 0x18, 0xab, 0x33, 0xf7, 0x0e, 0xec, 0xfe,
	0x41, 0x8f, 0x55, 0x7a, 0x9d, 0xfa, 0xb9, 0x6f, 0xf5, 0xdf, 0x03, 0xb9, 0x66, 0xd8, 0xfb, 0xd8,
	0x50, 0x4f, 0x0e, 0x75, 0x8f, 0x18, 0xba, 0xeb, 0xa9, 0xc4, 0xc2, 0xfb, 0x06, 0xd1, 0xe4, 0x87,
	0xf3, 0x7d, 0xe5, 0xfc, 0x8b, 0x7e, 0xee, 0x11, 0x93, 0x9c, 0xec, 0xad, 0x4f, 0xf5, 0x92, 0x13,
	0xa1, 0xd7, 0xc0, 0xeb, 0x33, 0x95, 0x25, 0x3b, 0xdb, 0x49, 0xe0, 0xf3, 0x28, 0xcc, 0x67, 0x9a,
	0x51, 0x7f, 0xcc, 0x89, 0x5b, 0xb8, 0x7d, 0x0c, 0xb3, 0x2c, 0x69, 0x9c, 0xd6, 0x89, 0xa3, 0xd3,
	0x20, 0x12, 0x2a, 0xaf, 0xa9, 0x5d, 0x5c, 0xf9, 0x31, 0xdb, 0x98, 0x5b, 0x34, 0x6b, 0x04, 0x44,
	0x7e, 0x75, 0xcd, 0x48, 0xd0, 0x2f, 0x24, 0x58, 0x6e, 0x86, 0x35, 0xd5, 0x6e, 0x78, 0x86, 0x4e,
	0x1c, 0x55, 0x23, 0x1e, 0x61, 0x35, 0x7c, 0xe8, 0x26, 0xf2, 0xa4, 0x37, 0x53, 0x96, 0x9a, 0x52,
	0x7e, 0xc8, 0x85, 0xac, 0xfb, 0x32, 0x82, 0x7b, 0xc9, 0x7b, 0x09, 0x16, 0xb2, 0xc0, 0xf0, 0x32,
	0xf2, 0xc3, 0xde, 0x80, 0xcc, 0xa6, 0x02, 0xe1, 0x55, 0xa5, 0x0e, 0xe3, 0x06, 0x36, 0xf7, 0x35,
	0xac, 0xfa, 0xde, 0xcb, 0xea, 0x38, 0xf9, 0xa3, 0xde, 0xc4, 0x22, 0xce, 0x74, 0x93, 0xf3, 0x64,
	0xb5, 0x1f, 0xf5, 0x07, 0xdf, 0xa1, 0xf8, 0xc6, 0xb5, 0xfa, 0xc3, 0xd3, 0x88, 0x3f, 0x08, 0xbf,
	0x62, 0xc4, 0x2d, 0xfe, 0xf0, 0x06, 0xe6, 0x05, 0x37, 0xff, 0x7a, 0xd4, 0xca, 0xee, 0x59, 0x98,
	0xdd, 0x0c, 0x27, 0x17, 0xb1, 0x36, 0xc9, 0x5b, 0x05, 0x3f, 0xac, 0x51, 0x47, 0x0b, 0xb8, 0xe1,
	0x7a, 0x9d, 0x58, 0x1a, 0xd1, 0xe4, 0xe7, 0x09, 0xe8, 0xd6, 0x28, 0x71, 0x93, 0xd9, 0x9a, 0x20,
	0x45, 0xdb, 0xfc, 0x16, 0x17, 0x30, 0x61, 0xdd, 0x16, 0x15, 0x3b, 0x0e, 0x3e, 0xf3, 0x03, 0xc9,
	0xf7, 0xa9, 0xbf, 0x36, 0xd9, 0x99, 0xf8, 0xb4, 0xc9, 0x66, 0x93, 0x12, 0xaf, 0x51, 0x5a, 0x11,
	0x5c, 0x7e, 0x0e, 0xf3, 0x0c, 0x13, 0x6b, 0x63, 0x04, 0x5e, 0x4a, 0xa3, 0xa0, 0xea, 0x7a, 0x1a,
	0x4b, 0x72, 0x3f, 0xe8, 0x6d, 0xc7, 0xa6, 0xa9, 0x1e, 0x8c, 0x7f, 0xd3, 0x43, 0x37, 0x6c, 0x67,
	0x97, 0x33, 0xdf, 0xca, 0xe5, 0x73, 0x85, 0xfe, 0xad, 0x5c, 0xbe, 0x58, 0xb8, 0xb5, 0x95, 0xcb,
	0xdf, 0x2a, 0x4c, 0x6f, 0xe5, 0xf2, 0x77, 0x0a, 0xe5, 0xad, 0x5c, 0xfe, 0x6e, 0x61, 0x85, 0xdd,
	0xbb, 0x5b, 0x82, 0x2b, 0x3b, 0x89, 0x2a, 0x39, 0x38, 0x20, 0xa1, 0xe0, 0xeb, 0x5f, 0x02, 0x95,
	0x45, 0xba, 0xc4, 0x21, 0x9e, 0xa3, 0xf3, 0x3b, 0x04, 0xbf, 0xc6, 0xaa, 0x96, 0x6d, 0x55, 0x89,
	0x2b, 0x1c, 0x44, 0x44, 0x84, 0xc8, 0xe5, 0x51, 0x23, 0x55, 0x7c, 0xc6, 0x7a, 0x12, 0xca, 0x52,
	0x26, 0x0b, 0xe1, 0x15, 0xa5, 0x3a, 0xdc, 0xf8, 0xb4, 0xae, 0x61, 0x8f, 0xf0, 0xde, 0x95, 0xb8,
	0x1e, 0xa3, 0x49, 0x18, 0xa0, 0xd9, 0x90, 0x38, 0xb2, 0x34, 0x2f, 0x95, 0x87, 0x14, 0xf1, 0x85,
	0x1e, 0xc3, 0x40, 0x9d, 0x11, 0xca, 0x57, 0xe7, 0xa5, 0xf2, 0xf0, 0xc3, 0xe9, 0xd5, 0x70, 0xab,
	0x6e, 0x35, 0xda, 0x08, 0x53, 0x04, 0xed, 0xf3, 0xe1, 0xf7, 0xdf, 0x7e, 0xb5, 0x22, 0x58, 0x94,
	0x26, 0x61, 0x3c, 0x2a, 0xd1, 0xad, 0xdb, 0x96, 0x4b, 0x4a, 0xff, 0x3a, 0x04, 0x13, 0x2c, 0xba,
	0x91, 0x37, 0xe4, 0x64, 0x8f, 0xdf, 0x21, 0x39, 0x18, 0x19, 0x06, 0x45, 0x8c, 0x14, 0x68, 0xfc,
	0x4f, 0x54, 0x84, 0xbc, 0x49, 0x3c, 0x4c, 0x73, 0x2e, 0x03, 0x34, 0xa4, 0x34, 0xbf, 0xd1, 0x1c,
	0x0c, 0x1b, 0xb6, 0xeb, 0xaa, 0x26, 0xf1, 0x0e, 0x6d, 0x4d, 0xce, 0xb1, 0x69, 0xa0, 0x43, 0xdb,
	0x6c, 0x04, 0x2d, 0xc0, 0x48, 0xac, 0x8f, 0x24, 0x95, 0xfb, 0x94, 0x61, 0x12, 0x6a, 0x22, 0x95,
	0xa1, 0x50, 0x73, 0xec, 0x86, 0xa5, 0xa9, 0x9e, 0xd3, 0xf0, 0x0e, 0x55, 0x03, 0xd7, 0xe4, 0x3c,
	0x23, 0x1b, 0xe5, 0xe3, 0x7b, 0x74, 0xf8, 0x35, 0xae, 0xd1, 0x6a, 0x8a, 0xa7, 0x1b, 0x19, 0xa8,
	0xa0, 0x1e, 0xaa, 0x29, 0x96, 0x65, 0xd0, 0x3b, 0x18, 0x61, 0x01, 0x4e, 0x84, 0x6f, 0x79, 0xb8,
	0x37, 0xae, 0xc3, 0x8c, 0x19, 0x8f, 0xf3, 0x68, 0x19, 0x46, 0x29, 0xd5, 0x89, 0x6a, 0x91, 0x1a,
	0xa6, 0xce, 0x27, 0x8f, 0xcc, 0x4b, 0xe5, 0xbc, 0x72, 0x8d, 0x8d, 0xbe, 0x11, 0x83, 0xe8, 0x13,
	0x18, 0x14, 0x95, 0x86, 0x7c, 0xad, 0x37, 0xe9, 0x3e, 0x1f, 0xf4, 0x14, 0x64, 0x11, 0xdc, 0xdc,
	0xc6, 0xbe, 0x70, 0x1c, 0xbf, 0xf1, 0x37, 0xca, 0xec, 0x3a, 0xc9, 0xe7, 0x77, 0x9b, 0xd3, 0xa2,
	0xf1, 0x77, 0x04, 0x13, 0x26, 0x71, 0x74, 0x4f, 0x75, 0x6d, 0xc7, 0xd3, 0x43, 0x09, 0x60, 0xac,
	0x37, 0x68, 0x37, 0x18, 0xd7, 0x5d, 0x9f, 0x29, 0x8f, 0xfa, 0x36, 0xdc, 0x14, 0x25, 0x91, 0xb8,
	0x84, 0x07, 0xc5, 0x4a, 0xa1, 0x37, 0x71, 0x13, 0x9c, 0xaf, 0xb8, 0xbb, 0x37, 0x8b, 0x95, 0x06,
	0x14, 0x85, 0xc0, 0xe0, 0xe6, 0x1e, 0xc8, 0xbc, 0xde, 0x9b, 0x4c, 0x99, 0xb3, 0x0e, 0x2e, 0xfc,
	0x4d, 0xb1, 0x81, 0x9e, 0x7e, 0x92, 0x68, 0xca, 0x44, 0x17, 0xa2, 0xa7, 0xc8, 0x26, 0x4d, 0x81,
	0x1f, 0xc2, 0x4d, 0x9e, 0x7c, 0x5a, 0x72, 0x9c, 0x7c, 0x83, 0xb9, 0xe0, 0x04, 0x9f, 0x8e, 0x25,
	0x35, 0xea, 0x37, 0x62, 0x5d, 0x4b, 0x36, 0x93, 0xc7, 0xd9, 0xc2, 0x49, 0x3e, 0x1f, 0x4f, 0x5f,
	0xcf, 0x47, 0x68, 0xe8, 0xf1, 0xe3, 0xc5, 0x56, 0x2e, 0xdf, 0x57, 0xc8, 0x6d, 0xe5, 0xf2, 0xfd,
	0x85, 0x81, 0xad, 0x5c, 0x7e, 0xa0, 0x30, 0xb8, 0x95, 0xcb, 0x0f, 0x15, 0x80, 0x87, 0x05, 0xd5,
	0xb0, 0x6b, 0x7a, 0x55, 0x19, 0x0b, 0x8a, 0x0e, 0x3e, 0x50, 0x08, 0x06, 0x78, 0x2c, 0x51, 0x86,
	0xfd, 0x3b, 0x3f, 0x76, 0x6a, 0xa5, 0x47, 0x30, 0x19, 0x0f, 0x5b, 0x3c, 0xa2, 0xa1, 0x29, 0xc8,
	0xf3, 0x08, 0xad, 0x6b, 0x2c, 0x70, 0xe5, 0x94, 0x41, 0xf6, 0xbd, 0xa9, 0x95, 0x7e, 0x25, 0xc1,
	0xad, 0x4d, 0xcb, 0x25, 0x8e, 0x27, 0x10, 0xef, 0xe0, 0x33, 0xc3, 0xc6, 0x5a, 0xbb, 0xf8, 0xfb,
	0x16, 0xc6, 0x7d, 0x0b, 0x1c, 0x63, 0xa3, 0x41, 0xd4, 0xfd, 0x86, 0xa5, 0x19, 0x44, 0x44, 0xe3,
	0xe5, 0x68, 0x34, 0x66, 0x79, 0x52, 0xf0, 0xff, 0x8c, 0x52, 0xbf, 0x60, 0xc4, 0x0a, 0x72, 0x5a,
	0xc6, 0xa2, 0x21, 0x7a, 0x16, 0xa6, 0x93, 0xc1, 0x89, 0x50, 0xfd, 0xb7, 0x12, 0x14, 0x39, 0x01,
	0xdf, 0xa8, 0x0e, 0xc1, 0x7f, 0x02, 0x48, 0x6c, 0x3b, 0xbb, 0x6e, 0x45, 0xa0, 0x2f, 0x26, 0x40,
	0xe7, 0xcc, 0xd7, 0xb1, 0x87, 0x05, 0xf0, 0xc2, 0x49, 0x6c, 0x24, 0x0a, 0x7b, 0xc6, 0xb7, 0x69,
	0x0c, 0x95, 0x40, 0xfd, 0xcf, 0x12, 0x8c, 0x29, 0xac, 0x7f, 0xd3, 0x6c, 0x03, 0xa7, 0x42, 0x0d,
	0x6f, 0x5d, 0x2e, 0xb2, 0x75, 0x68, 0x1c, 0xfa, 0xed, 0x13, 0x8b, 0x38, 0x72, 0x3f, 0x5b, 0xc1,
	0x3f, 0xd0, 0x0c, 0x80, 0xde, 0xcc, 0xaa, 0xf2, 0x00, 0xf3, 0xc9, 0x21, 0xdd, 0x15, 0x06, 0x8c,
	0xe0, 0xdc, 0xca, 0xe5, 0xaf, 0x16, 0xfa, 0xb8, 0x2f, 0x2a, 0xc3, 0x86, 0xbe, 0xaf, 0xd6, 0x1f,
	0xd6, 0xd5, 0x23, 0x72, 0xa6, 0x5c, 0x33, 0x1b, 0x86, 0xa7, 0xab, 0x58, 0xd3, 0x1c, 0xe2, 0xba,
	0xa5, 0x0d, 0x28, 0x04, 0x78, 0x85, 0x4f, 0xc9, 0x30, 0xe8, 0x36, 0xaa, 0xf4, 0x2e, 0xcb, 0x10,
	0xe7, 0x15, 0xff, 0x93, 0xce, 0x98, 0xc4, 0x75, 0x71, 0x8d, 0x88, 0x54, 0xe8, 0x7f, 0x96, 0xbe,
	0x80, 0x29, 0x76, 0xe7, 0x25, 0x4a, 0xa8, 0x7b, 0xd5, 0x8d, 0x05, 0xae, 0x46, 0x2d, 0x10, 0xd5,
	0xb5, 0x2f, 0x4b, 0xd7, 0xd2, 0x0e, 0x14, 0x93, 0x64, 0xf7, 0xa0, 0xcd, 0xaf, 0x24, 0x18, 0x5b,
	0xd3, 0x34, 0x71, 0x95, 0x3f, 0xb7, 0x12, 0x7f, 0x00, 0x03, 0xd8, 0xb4, 0x1b, 0x96, 0xc7, 0x14,
	0x38, 0xcf, 0x55, 0x5f, 0xac, 0x8f, 0xea, 0x8b, 0xa0, 0x10, 0x80, 0x13, 0x8e, 0xf7, 0x8f, 0x12,
	0x20, 0x25, 0x78, 0xcf, 0xfa, 0xdd, 0x03, 0x3d, 0x01, 0x37, 0x22, 0xf8, 0x04, 0xee, 0x77, 0x20,
	0x7f, 0x8c, 0xad, 0x2a, 0x31, 0x2e, 0x04, 0x7c, 0x54, 0xe4, 0x2d, 0x98, 0x4a, 0xe0, 0x2d, 0x04,
	0xff, 0x9b, 0x04, 0xe3, 0xeb, 0xc4, 0xa0, 0x85, 0x48, 0xcf, 0x26, 0x93, 0x61, 0x30, 0xec, 0xa9,
	0x43, 0x8a, 0xff, 0x19, 0x32, 0x66, 0xee, 0x22, 0x8d, 0x79, 0x13, 0x26, 0x62, 0xd8, 0x85, 0x56,
	0xff, 0x21, 0xf9, 0x67, 0xa1, 0x2b, 0xdd, 0x42, 0x0a, 0x5c, 0x8d, 0x2a, 0x10, 0xd6, 0xba, 0x2f,
	0xcd, 0x51, 0x2e, 0x54, 0xb7, 0x19, 0xb8, 0x95, 0xa8, 0x81, 0xd0, 0xf0, 0x97, 0x12, 0xcc, 0x87,
	0x77, 0xf5, 0xa2, 0xf6, 0x70, 0x1a, 0x86, 0x34, 0xce, 0xca, 0xf6, 0x77, 0x31, 0x18, 0x08, 0x1b,
	0x28, 0x17, 0x31, 0x50, 0x14, 0xfb, 0x22, 0x2c, 0x64, 0x60, 0x13, 0x1a, 0x1c, 0xd3, 0x2d, 0x3a,
	0xc1, 0x8e, 0x76, 0xe9, 0xee, 0x97, 0x60, 0xd8, 0x04, 0xb9, 0x02, 0xd6, 0xdf, 0x4b, 0x50, 0xd8,
	0xa0, 0xd7, 0x8d, 0xf0, 0xb5, 0xe8, 0x77, 0x27, 0x7e, 0xdc, 0x80, 0xeb, 0x21, 0x74, 0x02, 0xf3,
	0xe7, 0x50, 0x5c, 0xd3, 0xb4, 0x3d, 0x3b, 0xb8, 0xfd, 0x6b, 0xa6, 0x6e, 0x75, 0xe0, 0xed, 0x22,
	0xfd, 0xf9, 0xde, 0x2e, 0x3e, 0x5b, 0xec, 0x95, 0xc8, 0x5c, 0xc8, 0xfe, 0x31, 0xcc, 0xf1, 0x5d,
	0xde, 0x70, 0x6c, 0xf3, 0x52, 0x00, 0x94, 0x60, 0x3e, 0x5d, 0x82, 0x40, 0x51, 0x85, 0x05, 0xde,
	0x3e, 0xe1, 0x3f, 0xb2, 0x88, 0xd6, 0xb4, 0x17, 0x15, 0x48, 0x97, 0xa0, 0x94, 0x25, 0x44, 0x40,
	0xd1, 0xa0, 0xb4, 0xae, 0xbb, 0x97, 0x8d, 0x65, 0x19, 0x16, 0x33, 0xa5, 0x04, 0x60, 0x42, 0x90,
	0xe3, 0x25, 0xfb, 0x05, 0x82, 0xc9, 0x94, 0x22, 0xc0, 0x90, 0x28, 0xe6, 0xcb, 0x42, 0x73, 0x1b,
	0x96, 0xb2, 0xc5, 0x08, 0x38, 0x3f, 0x12, 0x8e, 0xfd, 0x2a, 0xda, 0x34, 0xbe, 0x20, 0xaf, 0x9d,
	0x85, 0xe9, 0x64, 0xee, 0x42, 0x3a, 0x0e, 0x7b, 0xf5, 0xe5, 0x40, 0x58, 0x84, 0x85, 0x0c, 0x11,
	0x02, 0xc7, 0x3e, 0x2c, 0x30, 0x9c, 0x7b, 0x49, 0x2d, 0xef, 0x0b, 0x02, 0xb2, 0x04, 0xa5, 0x2c,
	0x19, 0x31, 0x24, 0xaf, 0x92, 0x9a, 0xad, 0x17, 0x8c, 0x24, 0x45, 0x86, 0x40, 0x52, 0x83, 0xdb,
	0x2d, 0x86, 0xbb, 0x14, 0x38, 0x77, 0xe1, 0x4e, 0x5b, 0x41, 0xcd, 0x08, 0x17, 0x46, 0xde, 0xed,
	0xd9, 0xe9, 0x10, 0xcf, 0x32, 0x2c, 0x66, 0x0a, 0x11, 0x58, 0x0e, 0x5b, 0x61, 0x5f, 0x12, 0xa0,
	0x15, 0x28, 0xb7, 0x97, 0x14, 0x9c, 0xa8, 0x10, 0xf8, 0x68, 0x3b, 0xfc, 0xe2, 0x4e, 0x54, 0x86,
	0x08, 0x81, 0xe3, 0x00, 0x96, 0xe3, 0x98, 0x2f, 0x05, 0x4c, 0xb9, 0xd5, 0x4b, 0x53, 0x10, 0xfd,
	0x04, 0x96, 0x5f, 0x34, 0x8c, 0xa3, 0xf3, 0x9f, 0xae, 0x69, 0x18, 0x12, 0x10, 0x88, 0xcb, 0x7e,
	0x3c, 0x39, 0xa4, 0x04, 0x03, 0x2d, 0xa8, 0xda, 0xc9, 0x12, 0xa8, 0x6c, 0x58, 0xa1, 0x94, 0x3d,
	0x9e, 0xb4, 0x2e, 0xa0, 0xdd, 0x87, 0xef, 0x75, 0x24, 0x50, 0xe0, 0x3b, 0x6a, 0xd1, 0xa4, 0x5b,
	0x27, 0xef, 0x02, 0xdb, 0x5d, 0xb8, 0xd3, 0x56, 0x98, 0xc0, 0x55, 0x4f, 0x56, 0xe3, 0x12, 0xc1,
	0xad, 0xc2, 0xbd, 0xce, 0x24, 0x0a, 0x84, 0x7f, 0x26, 0xc1, 0x52, 0x53, 0x9b, 0xf3, 0x54, 0x41,
	0x99, 0xd8, 0x32, 0x2e, 0x63, 0x51, 0xd8, 0x77, 0x42, 0x6e, 0x9f, 0x59, 0x25, 0xfd, 0x85, 0x04,
	0x77, 0xa3, 0x0a, 0x7e, 0x77, 0xa0, 0xef, 0xc5, 0x4f, 0x45, 0x26, 0xf2, 0x2f, 0xa5, 0xb8, 0x8e,
	0x17, 0xea, 0x06, 0x1d, 0xa3, 0x0e, 0x9f, 0xfa, 0xec, 0xaa, 0xeb, 0x17, 0x52, 0xa2, 0x82, 0xdf,
	0x0d, 0xec, 0x96, 0x88, 0x90, 0x8d, 0x3d, 0x52, 0x17, 0x5c, 0x66, 0xc1, 0x14, 0xa9, 0x0b, 0xb2,
	0xab, 0xa6, 0x9f, 0x89, 0xac, 0x77, 0x1e, 0x8f, 0x4d, 0x45, 0xd3, 0xb1, 0x01, 0x17, 0xc3, 0xd5,
	0x63, 0x9a, 0x93, 0xfe, 0xa9, 0x14, 0xce, 0x88, 0xdf, 0x0d, 0xd0, 0x72, 0xcb, 0xd6, 0xa5, 0xa1,
	0xfd, 0xe3, 0xb0, 0x4a, 0x17, 0x56, 0xd6, 0x74, 0x0c, 0x34, 0x52, 0x2b, 0xa7, 0x7a, 0xe2, 0x7b,
	0xa9, 0x45, 0x9f, 0xff, 0x7f, 0xa8, 0xad, 0x5e, 0x9a, 0x86, 0xf7, 0xe1, 0x7f, 0x95, 0x01, 0xb6,
	0xdd, 0xda, 0x2e, 0x71, 0x8e, 0xf5, 0x2a, 0x41, 0x9f, 0xc2, 0x48, 0xf8, 0x61, 0x1a, 0x2d, 0x44,
	0x9f, 0x24, 0x12, 0x9e, 0xc9, 0x8b, 0xa5, 0x2c, 0x12, 0xd1, 0xe3, 0xfe, 0x1c, 0x46, 0xa3, 0xef,
	0x43, 0x28, 0xf6, 0xd6, 0x91, 0xf8, 0xe8, 0x5d, 0x5c, 0xca, 0x26, 0x12, 0xcc, 0x37, 0x21, 0xef,
	0x3f, 0x11, 0xa0, 0x99, 0xe8, 0x8a, 0xd8, 0x53, 0x47, 0x71, 0x36, 0x6d, 0x5a, 0xb0, 0xaa, 0xf9,
	0x4d, 0xea, 0x70, 0xa7, 0x1e, 0xdd, 0x89, 0xaf, 0x4a, 0x79, 0x47, 0x28, 0x96, 0xdb, 0x13, 0x06,
	0x98, 0xfd, 0x16, 0x79, 0x1c, 0x73, 0xac, 0xaf, 0x1f, 0xc7, 0x1c, 0xef, 0xac, 0x23, 0x05, 0x86,
	0x43, 0xfd, 0x63, 0x34, 0x9f, 0x84, 0x21, 0xc2, 0x70, 0x21, 0x83, 0x42, 0xf0, 0xd4, 0xe0, 0x7a,
	0x4b, 0x67, 0x1a, 0xdd, 0x8e, 0xed, 0x46, 0x4a, 0x5b, 0xbc, 0x78, 0xa7, 0x2d, 0x9d, 0x90, 0xf2,
	0x87, 0x70, 0x2d, 0xd2, 0xea, 0x43, 0x31, 0x57, 0x4a, 0xea, 0x3f, 0x16, 0x17, 0x33, 0x69, 0x04,
	0xe7, 0x9f, 0xc0, 0x8d, 0x84, 0x56, 0x22, 0x6a, 0xd9, 0x9f, 0xb4, 0x2e, 0x67, 0xf1, 0x6e, 0x07,
	0x94, 0x61, 0x59, 0x2d, 0xdd, 0x54, 0x94, 0xe8, 0x0b, 0x9d, 0xc9, 0x4a, 0x6d, 0xcd, 0xa2, 0x9f,
	0x45, 0x5f, 0x0c, 0xa2, 0x12, 0x57, 0xd3, 0xed, 0x9e, 0x28, 0xb7, 0xd2, 0x31, 0xbd, 0x90, 0xfe,
	0x1a, 0x86, 0x9a, 0x2d, 0x4e, 0x14, 0x73, 0xcb, 0x78, 0x67, 0xb6, 0x38, 0x97, 0x3a, 0x1f, 0xd8,
	0x2d, 0xa1, 0x7d, 0x19, 0xb7, 0x5b, 0x7a, 0xfb, 0x34, 0x6e, 0xb7, 0x8c, 0x5e, 0x28, 0x3a, 0x03,
	0x39, 0xad, 0x53, 0x89, 0xee, 0x27, 0x99, 0x3f, 0xb5, 0x67, 0x5a, 0x5c, 0xed, 0x94, 0x3c, 0x50,
	0x33, 0xe1, 0x41, 0x36, 0xae, 0x66, 0xfa, 0x4b, 0x72, 0x5c, 0xcd, 0x8c, 0xd7, 0x5d, 0x64, 0xc2,
	0x78, 0xd2, 0x9b, 0x35, 0x4a, 0x64, 0x91, 0xf8, 0xe8, 0x5e, 0x5c, 0xe9, 0x84, 0x34, 0x10, 0x97,
	0xd4, 0x49, 0x43, 0x49, 0x1b, 0x93, 0xdc, 0x48, 0x8b, 0x8b, 0xcb, 0x6a, 0xcc, 0x51, 0xe7, 0x4f,
	0xed, 0x9a, 0xa1, 0xd4, 0x6d, 0x49, 0x11, 0x5c, 0xe9, 0x98, 0x5e, 0x48, 0xff, 0xb9, 0x68, 0xe5,
	0x27, 0x5e, 0x4d, 0x51, 0x25, 0x5d, 0x8f, 0xc4, 0x82, 0xaa, 0xf8, 0xa0, 0xf3, 0x05, 0x02, 0xc0,
	0x5f, 0x49, 0xe1, 0x86, 0x7e, 0x32, 0x8c, 0xc7, 0x6d, 0xb4, 0x4a, 0xc6, 0xf2, 0xa4, 0xcb, 0x55,
	0x02, 0xd0, 0x7b, 0x29, 0xd2, 0xa7, 0x8d, 0x97, 0x18, 0x28, 0x5d, 0xc5, 0x94, 0x8a, 0xa8, 0xf8,
	0x41, 0x17, 0x2b, 0x04, 0x88, 0xbf, 0x91, 0x5a, 0xdb, 0xb5, 0x2d, 0x48, 0xda, 0x28, 0x98, 0x06,
	0xe7, 0xc3, 0x6e, 0x97, 0x05, 0x8e, 0x9a, 0xda, 0x8c, 0x8a, 0x3b, 0x6a, 0xbb, 0xc6, 0x58, 0xb1,
	0xd2, 0x31, 0xbd, 0x90, 0xfe, 0x97, 0x12, 0xcc, 0x66, 0xb7, 0x9f, 0xd0, 0xa3, 0x6c, 0xc5, 0x92,
	0x81, 0x3c, 0xee, 0x6e, 0x51, 0x08, 0x4d, 0x76, 0xdb, 0x29, 0x8e, 0xa6, 0xa3, 0x86, 0x58, 0x1c,
	0x4d, 0x67, 0x9d, 0x2d, 0xf4, 0x4b, 0x09, 0x16, 0x3b, 0xe8, 0x34, 0xa1, 0xa7, 0xad, 0xdc, 0x3b,
	0x3c, 0x4b, 0xcf, 0xce, 0xb1, 0x32, 0x74, 0xc0, 0xdb, 0xb4, 0x9a, 0x50, 0xb6, 0xda, 0x69, 0x8e,
	0xfc, 0xa4, 0xcb, 0x55, 0x02, 0xd0, 0x3f, 0x88, 0x6e, 0x51, 0xdb, 0xf3, 0xd5, 0x81, 0xd2, 0x69,
	0xd0, 0x9e, 0x9f, 0x67, 0xa9, 0xc0, 0xf7, 0xe7, 0x12, 0xcc, 0x64, 0xf6, 0x91, 0xd0, 0xc3, 0x14,
	0xc5, 0x33, 0xae, 0xba, 0xc5, 0x47, 0x5d, 0xad, 0x11, 0x50, 0xfe, 0x4e, 0x82, 0x52, 0xfb, 0xee,
	0x10, 0xfa, 0x28, 0x4b, 0xdb, 0x2c, 0x50, 0x4f, 0xbb, 0x5f, 0x98, 0x74, 0x00, 0x13, 0xef, 0x82,
	0x28, 0x53, 0xe3, 0xb4, 0x8d, 0x7b, 0xdc, 0xdd, 0xa2, 0xd4, 0x03, 0x98, 0x0c, 0xa9, 0xbd, 0xbe,
	0x69, 0xb8, 0x9e, 0x9d, 0x63, 0x65, 0x90, 0xe2, 0xd3, 0x9f, 0x91, 0xe3, 0x29, 0xbe, 0xed, 0xab,
	0x76, 0x3c, 0xc5, 0xb7, 0x7f, 0xa1, 0x66, 0x19, 0x35, 0xe3, 0xf1, 0x38, 0x9e, 0x51, 0xdb, 0xbf,
	0x66, 0xc7, 0x33, 0x6a, 0x07, 0x2f, 0xd3, 0x0c, 0x44, 0xc6, 0xa3, 0x31, 0x4a, 0x57, 0xab, 0xc3,
	0xb4, 0xde, 0xc1, 0x8b, 0x34, 0xfa, 0x52, 0x82, 0xe9, 0xac, 0xb7, 0x62, 0x94, 0xa1, 0x58, 0x1a,
	0x8c, 0x87, 0xdd, 0x2c, 0x89, 0x55, 0x7d, 0x89, 0xad, 0xbe, 0xc4, 0xaa, 0x2f, 0xab, 0xfb, 0x98,
	0x58, 0xf5, 0x65, 0x76, 0x11, 0x63, 0x55, 0x5f, 0x32, 0x8c, 0xd4, 0xcc, 0x9c, 0x89, 0xe5, 0x49,
	0x97, 0xab, 0x62, 0xc5, 0x4d, 0xa2, 0x83, 0xae, 0xa6, 0xe9, 0x97, 0xe2, 0x9e, 0x95, 0x8e, 0xe9,
	0x13, 0x8b, 0x9b, 0x44, 0x0c, 0x8f, 0x32, 0xf5, 0xea, 0xac, 0x9c, 0xe8, 0x30, 0xb6, 0x46, 0xbc,
	0xa3, 0xc5, 0x45, 0x53, 0x95, 0x4b, 0x73, 0xd0, 0x07, 0x9d, 0x2f, 0x48, 0xf7, 0x8e, 0x76, 0x25,
	0x43, 0x87, 0x61, 0xf4, 0x49, 0x97, 0xab, 0x38, 0xa0, 0x62, 0xff, 0x9f, 0x7c, 0xfb, 0xd5, 0x8a,
	0xf4, 0x42, 0xf9, 0xf5, 0xd7, 0xb3, 0xd2, 0x6f, 0xbe, 0x9e, 0x95, 0xfe, 0xf7, 0xeb, 0x59, 0xe9,
	0xaf, 0xbf, 0x99, 0xbd, 0xf2, 0x9b, 0x6f, 0x66, 0xaf, 0xfc, 0xf7, 0x37, 0xb3, 0x57, 0xde, 0x3d,
	0xed, 0xf0, 0x57, 0xf4, 0xa7, 0x95, 0xe0, 0x2f, 0xd1, 0x78, 0x67, 0x75, 0xe2, 0xee, 0x0f, 0xb0,
	0xbf, 0x35, 0xf3, 0xe8, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc2, 0xd7, 0xd7, 0x55, 0x30, 0x47,
	0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgServiceClient is the client API for MsgService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgServiceClient interface {
	UpdateParams(ctx context.Context, in *UpdateParamsRequest, opts ...grpc.CallOption) (*UpdateParamsResponse, error)
	CreateNewTopic(ctx context.Context, in *CreateNewTopicRequest, opts ...grpc.CallOption) (*CreateNewTopicResponse, error)
	Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
	RemoveRegistration(ctx context.Context, in *RemoveRegistrationRequest, opts ...grpc.CallOption) (*RemoveRegistrationResponse, error)
	AddStake(ctx context.Context, in *AddStakeRequest, opts ...grpc.CallOption) (*AddStakeResponse, error)
	RemoveStake(ctx context.Context, in *RemoveStakeRequest, opts ...grpc.CallOption) (*RemoveStakeResponse, error)
	CancelRemoveStake(ctx context.Context, in *CancelRemoveStakeRequest, opts ...grpc.CallOption) (*CancelRemoveStakeResponse, error)
	DelegateStake(ctx context.Context, in *DelegateStakeRequest, opts ...grpc.CallOption) (*DelegateStakeResponse, error)
	RewardDelegateStake(ctx context.Context, in *RewardDelegateStakeRequest, opts ...grpc.CallOption) (*RewardDelegateStakeResponse, error)
	RemoveDelegateStake(ctx context.Context, in *RemoveDelegateStakeRequest, opts ...grpc.CallOption) (*RemoveDelegateStakeResponse, error)
	CancelRemoveDelegateStake(ctx context.Context, in *CancelRemoveDelegateStakeRequest, opts ...grpc.CallOption) (*CancelRemoveDelegateStakeResponse, error)
	FundTopic(ctx context.Context, in *FundTopicRequest, opts ...grpc.CallOption) (*FundTopicResponse, error)
	AddToWhitelistAdmin(ctx context.Context, in *AddToWhitelistAdminRequest, opts ...grpc.CallOption) (*AddToWhitelistAdminResponse, error)
	RemoveFromWhitelistAdmin(ctx context.Context, in *RemoveFromWhitelistAdminRequest, opts ...grpc.CallOption) (*RemoveFromWhitelistAdminResponse, error)
	InsertWorkerPayload(ctx context.Context, in *InsertWorkerPayloadRequest, opts ...grpc.CallOption) (*InsertWorkerPayloadResponse, error)
	InsertReputerPayload(ctx context.Context, in *InsertReputerPayloadRequest, opts ...grpc.CallOption) (*InsertReputerPayloadResponse, error)
	AddToGlobalWhitelist(ctx context.Context, in *AddToGlobalWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalWhitelistResponse, error)
	RemoveFromGlobalWhitelist(ctx context.Context, in *RemoveFromGlobalWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalWhitelistResponse, error)
	AddToGlobalWorkerWhitelist(ctx context.Context, in *AddToGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalWorkerWhitelistResponse, error)
	RemoveFromGlobalWorkerWhitelist(ctx context.Context, in *RemoveFromGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalWorkerWhitelistResponse, error)
	AddToGlobalReputerWhitelist(ctx context.Context, in *AddToGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalReputerWhitelistResponse, error)
	RemoveFromGlobalReputerWhitelist(ctx context.Context, in *RemoveFromGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalReputerWhitelistResponse, error)
	AddToGlobalAdminWhitelist(ctx context.Context, in *AddToGlobalAdminWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalAdminWhitelistResponse, error)
	RemoveFromGlobalAdminWhitelist(ctx context.Context, in *RemoveFromGlobalAdminWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalAdminWhitelistResponse, error)
	BulkAddToGlobalWorkerWhitelist(ctx context.Context, in *BulkAddToGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToGlobalWorkerWhitelistResponse, error)
	BulkRemoveFromGlobalWorkerWhitelist(ctx context.Context, in *BulkRemoveFromGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromGlobalWorkerWhitelistResponse, error)
	BulkAddToGlobalReputerWhitelist(ctx context.Context, in *BulkAddToGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToGlobalReputerWhitelistResponse, error)
	BulkRemoveFromGlobalReputerWhitelist(ctx context.Context, in *BulkRemoveFromGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromGlobalReputerWhitelistResponse, error)
	BulkAddToTopicWorkerWhitelist(ctx context.Context, in *BulkAddToTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToTopicWorkerWhitelistResponse, error)
	BulkRemoveFromTopicWorkerWhitelist(ctx context.Context, in *BulkRemoveFromTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromTopicWorkerWhitelistResponse, error)
	BulkAddToTopicReputerWhitelist(ctx context.Context, in *BulkAddToTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToTopicReputerWhitelistResponse, error)
	BulkRemoveFromTopicReputerWhitelist(ctx context.Context, in *BulkRemoveFromTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromTopicReputerWhitelistResponse, error)
	EnableTopicWorkerWhitelist(ctx context.Context, in *EnableTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*EnableTopicWorkerWhitelistResponse, error)
	DisableTopicWorkerWhitelist(ctx context.Context, in *DisableTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*DisableTopicWorkerWhitelistResponse, error)
	EnableTopicReputerWhitelist(ctx context.Context, in *EnableTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*EnableTopicReputerWhitelistResponse, error)
	DisableTopicReputerWhitelist(ctx context.Context, in *DisableTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*DisableTopicReputerWhitelistResponse, error)
	AddToTopicCreatorWhitelist(ctx context.Context, in *AddToTopicCreatorWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicCreatorWhitelistResponse, error)
	RemoveFromTopicCreatorWhitelist(ctx context.Context, in *RemoveFromTopicCreatorWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicCreatorWhitelistResponse, error)
	AddToTopicWorkerWhitelist(ctx context.Context, in *AddToTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicWorkerWhitelistResponse, error)
	RemoveFromTopicWorkerWhitelist(ctx context.Context, in *RemoveFromTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicWorkerWhitelistResponse, error)
	AddToTopicReputerWhitelist(ctx context.Context, in *AddToTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicReputerWhitelistResponse, error)
	RemoveFromTopicReputerWhitelist(ctx context.Context, in *RemoveFromTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicReputerWhitelistResponse, error)
}

type msgServiceClient struct {
	cc grpc1.ClientConn
}

func NewMsgServiceClient(cc grpc1.ClientConn) MsgServiceClient {
	return &msgServiceClient{cc}
}

func (c *msgServiceClient) UpdateParams(ctx context.Context, in *UpdateParamsRequest, opts ...grpc.CallOption) (*UpdateParamsResponse, error) {
	out := new(UpdateParamsResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/UpdateParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) CreateNewTopic(ctx context.Context, in *CreateNewTopicRequest, opts ...grpc.CallOption) (*CreateNewTopicResponse, error) {
	out := new(CreateNewTopicResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/CreateNewTopic", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
	out := new(RegisterResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/Register", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveRegistration(ctx context.Context, in *RemoveRegistrationRequest, opts ...grpc.CallOption) (*RemoveRegistrationResponse, error) {
	out := new(RemoveRegistrationResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveRegistration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddStake(ctx context.Context, in *AddStakeRequest, opts ...grpc.CallOption) (*AddStakeResponse, error) {
	out := new(AddStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveStake(ctx context.Context, in *RemoveStakeRequest, opts ...grpc.CallOption) (*RemoveStakeResponse, error) {
	out := new(RemoveStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) CancelRemoveStake(ctx context.Context, in *CancelRemoveStakeRequest, opts ...grpc.CallOption) (*CancelRemoveStakeResponse, error) {
	out := new(CancelRemoveStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/CancelRemoveStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) DelegateStake(ctx context.Context, in *DelegateStakeRequest, opts ...grpc.CallOption) (*DelegateStakeResponse, error) {
	out := new(DelegateStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/DelegateStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RewardDelegateStake(ctx context.Context, in *RewardDelegateStakeRequest, opts ...grpc.CallOption) (*RewardDelegateStakeResponse, error) {
	out := new(RewardDelegateStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RewardDelegateStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveDelegateStake(ctx context.Context, in *RemoveDelegateStakeRequest, opts ...grpc.CallOption) (*RemoveDelegateStakeResponse, error) {
	out := new(RemoveDelegateStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveDelegateStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) CancelRemoveDelegateStake(ctx context.Context, in *CancelRemoveDelegateStakeRequest, opts ...grpc.CallOption) (*CancelRemoveDelegateStakeResponse, error) {
	out := new(CancelRemoveDelegateStakeResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/CancelRemoveDelegateStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) FundTopic(ctx context.Context, in *FundTopicRequest, opts ...grpc.CallOption) (*FundTopicResponse, error) {
	out := new(FundTopicResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/FundTopic", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToWhitelistAdmin(ctx context.Context, in *AddToWhitelistAdminRequest, opts ...grpc.CallOption) (*AddToWhitelistAdminResponse, error) {
	out := new(AddToWhitelistAdminResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToWhitelistAdmin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromWhitelistAdmin(ctx context.Context, in *RemoveFromWhitelistAdminRequest, opts ...grpc.CallOption) (*RemoveFromWhitelistAdminResponse, error) {
	out := new(RemoveFromWhitelistAdminResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromWhitelistAdmin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) InsertWorkerPayload(ctx context.Context, in *InsertWorkerPayloadRequest, opts ...grpc.CallOption) (*InsertWorkerPayloadResponse, error) {
	out := new(InsertWorkerPayloadResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/InsertWorkerPayload", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) InsertReputerPayload(ctx context.Context, in *InsertReputerPayloadRequest, opts ...grpc.CallOption) (*InsertReputerPayloadResponse, error) {
	out := new(InsertReputerPayloadResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/InsertReputerPayload", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToGlobalWhitelist(ctx context.Context, in *AddToGlobalWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalWhitelistResponse, error) {
	out := new(AddToGlobalWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToGlobalWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromGlobalWhitelist(ctx context.Context, in *RemoveFromGlobalWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalWhitelistResponse, error) {
	out := new(RemoveFromGlobalWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromGlobalWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToGlobalWorkerWhitelist(ctx context.Context, in *AddToGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalWorkerWhitelistResponse, error) {
	out := new(AddToGlobalWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToGlobalWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromGlobalWorkerWhitelist(ctx context.Context, in *RemoveFromGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalWorkerWhitelistResponse, error) {
	out := new(RemoveFromGlobalWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromGlobalWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToGlobalReputerWhitelist(ctx context.Context, in *AddToGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalReputerWhitelistResponse, error) {
	out := new(AddToGlobalReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToGlobalReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromGlobalReputerWhitelist(ctx context.Context, in *RemoveFromGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalReputerWhitelistResponse, error) {
	out := new(RemoveFromGlobalReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromGlobalReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToGlobalAdminWhitelist(ctx context.Context, in *AddToGlobalAdminWhitelistRequest, opts ...grpc.CallOption) (*AddToGlobalAdminWhitelistResponse, error) {
	out := new(AddToGlobalAdminWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToGlobalAdminWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromGlobalAdminWhitelist(ctx context.Context, in *RemoveFromGlobalAdminWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromGlobalAdminWhitelistResponse, error) {
	out := new(RemoveFromGlobalAdminWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromGlobalAdminWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkAddToGlobalWorkerWhitelist(ctx context.Context, in *BulkAddToGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToGlobalWorkerWhitelistResponse, error) {
	out := new(BulkAddToGlobalWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkAddToGlobalWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkRemoveFromGlobalWorkerWhitelist(ctx context.Context, in *BulkRemoveFromGlobalWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromGlobalWorkerWhitelistResponse, error) {
	out := new(BulkRemoveFromGlobalWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkRemoveFromGlobalWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkAddToGlobalReputerWhitelist(ctx context.Context, in *BulkAddToGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToGlobalReputerWhitelistResponse, error) {
	out := new(BulkAddToGlobalReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkAddToGlobalReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkRemoveFromGlobalReputerWhitelist(ctx context.Context, in *BulkRemoveFromGlobalReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromGlobalReputerWhitelistResponse, error) {
	out := new(BulkRemoveFromGlobalReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkRemoveFromGlobalReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkAddToTopicWorkerWhitelist(ctx context.Context, in *BulkAddToTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToTopicWorkerWhitelistResponse, error) {
	out := new(BulkAddToTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkAddToTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkRemoveFromTopicWorkerWhitelist(ctx context.Context, in *BulkRemoveFromTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromTopicWorkerWhitelistResponse, error) {
	out := new(BulkRemoveFromTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkRemoveFromTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkAddToTopicReputerWhitelist(ctx context.Context, in *BulkAddToTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkAddToTopicReputerWhitelistResponse, error) {
	out := new(BulkAddToTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkAddToTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) BulkRemoveFromTopicReputerWhitelist(ctx context.Context, in *BulkRemoveFromTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*BulkRemoveFromTopicReputerWhitelistResponse, error) {
	out := new(BulkRemoveFromTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/BulkRemoveFromTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) EnableTopicWorkerWhitelist(ctx context.Context, in *EnableTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*EnableTopicWorkerWhitelistResponse, error) {
	out := new(EnableTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/EnableTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) DisableTopicWorkerWhitelist(ctx context.Context, in *DisableTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*DisableTopicWorkerWhitelistResponse, error) {
	out := new(DisableTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/DisableTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) EnableTopicReputerWhitelist(ctx context.Context, in *EnableTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*EnableTopicReputerWhitelistResponse, error) {
	out := new(EnableTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/EnableTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) DisableTopicReputerWhitelist(ctx context.Context, in *DisableTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*DisableTopicReputerWhitelistResponse, error) {
	out := new(DisableTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/DisableTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToTopicCreatorWhitelist(ctx context.Context, in *AddToTopicCreatorWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicCreatorWhitelistResponse, error) {
	out := new(AddToTopicCreatorWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToTopicCreatorWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromTopicCreatorWhitelist(ctx context.Context, in *RemoveFromTopicCreatorWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicCreatorWhitelistResponse, error) {
	out := new(RemoveFromTopicCreatorWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromTopicCreatorWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToTopicWorkerWhitelist(ctx context.Context, in *AddToTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicWorkerWhitelistResponse, error) {
	out := new(AddToTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromTopicWorkerWhitelist(ctx context.Context, in *RemoveFromTopicWorkerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicWorkerWhitelistResponse, error) {
	out := new(RemoveFromTopicWorkerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromTopicWorkerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) AddToTopicReputerWhitelist(ctx context.Context, in *AddToTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*AddToTopicReputerWhitelistResponse, error) {
	out := new(AddToTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/AddToTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgServiceClient) RemoveFromTopicReputerWhitelist(ctx context.Context, in *RemoveFromTopicReputerWhitelistRequest, opts ...grpc.CallOption) (*RemoveFromTopicReputerWhitelistResponse, error) {
	out := new(RemoveFromTopicReputerWhitelistResponse)
	err := c.cc.Invoke(ctx, "/emissions.v9.MsgService/RemoveFromTopicReputerWhitelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServiceServer is the server API for MsgService service.
type MsgServiceServer interface {
	UpdateParams(context.Context, *UpdateParamsRequest) (*UpdateParamsResponse, error)
	CreateNewTopic(context.Context, *CreateNewTopicRequest) (*CreateNewTopicResponse, error)
	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
	RemoveRegistration(context.Context, *RemoveRegistrationRequest) (*RemoveRegistrationResponse, error)
	AddStake(context.Context, *AddStakeRequest) (*AddStakeResponse, error)
	RemoveStake(context.Context, *RemoveStakeRequest) (*RemoveStakeResponse, error)
	CancelRemoveStake(context.Context, *CancelRemoveStakeRequest) (*CancelRemoveStakeResponse, error)
	DelegateStake(context.Context, *DelegateStakeRequest) (*DelegateStakeResponse, error)
	RewardDelegateStake(context.Context, *RewardDelegateStakeRequest) (*RewardDelegateStakeResponse, error)
	RemoveDelegateStake(context.Context, *RemoveDelegateStakeRequest) (*RemoveDelegateStakeResponse, error)
	CancelRemoveDelegateStake(context.Context, *CancelRemoveDelegateStakeRequest) (*CancelRemoveDelegateStakeResponse, error)
	FundTopic(context.Context, *FundTopicRequest) (*FundTopicResponse, error)
	AddToWhitelistAdmin(context.Context, *AddToWhitelistAdminRequest) (*AddToWhitelistAdminResponse, error)
	RemoveFromWhitelistAdmin(context.Context, *RemoveFromWhitelistAdminRequest) (*RemoveFromWhitelistAdminResponse, error)
	InsertWorkerPayload(context.Context, *InsertWorkerPayloadRequest) (*InsertWorkerPayloadResponse, error)
	InsertReputerPayload(context.Context, *InsertReputerPayloadRequest) (*InsertReputerPayloadResponse, error)
	AddToGlobalWhitelist(context.Context, *AddToGlobalWhitelistRequest) (*AddToGlobalWhitelistResponse, error)
	RemoveFromGlobalWhitelist(context.Context, *RemoveFromGlobalWhitelistRequest) (*RemoveFromGlobalWhitelistResponse, error)
	AddToGlobalWorkerWhitelist(context.Context, *AddToGlobalWorkerWhitelistRequest) (*AddToGlobalWorkerWhitelistResponse, error)
	RemoveFromGlobalWorkerWhitelist(context.Context, *RemoveFromGlobalWorkerWhitelistRequest) (*RemoveFromGlobalWorkerWhitelistResponse, error)
	AddToGlobalReputerWhitelist(context.Context, *AddToGlobalReputerWhitelistRequest) (*AddToGlobalReputerWhitelistResponse, error)
	RemoveFromGlobalReputerWhitelist(context.Context, *RemoveFromGlobalReputerWhitelistRequest) (*RemoveFromGlobalReputerWhitelistResponse, error)
	AddToGlobalAdminWhitelist(context.Context, *AddToGlobalAdminWhitelistRequest) (*AddToGlobalAdminWhitelistResponse, error)
	RemoveFromGlobalAdminWhitelist(context.Context, *RemoveFromGlobalAdminWhitelistRequest) (*RemoveFromGlobalAdminWhitelistResponse, error)
	BulkAddToGlobalWorkerWhitelist(context.Context, *BulkAddToGlobalWorkerWhitelistRequest) (*BulkAddToGlobalWorkerWhitelistResponse, error)
	BulkRemoveFromGlobalWorkerWhitelist(context.Context, *BulkRemoveFromGlobalWorkerWhitelistRequest) (*BulkRemoveFromGlobalWorkerWhitelistResponse, error)
	BulkAddToGlobalReputerWhitelist(context.Context, *BulkAddToGlobalReputerWhitelistRequest) (*BulkAddToGlobalReputerWhitelistResponse, error)
	BulkRemoveFromGlobalReputerWhitelist(context.Context, *BulkRemoveFromGlobalReputerWhitelistRequest) (*BulkRemoveFromGlobalReputerWhitelistResponse, error)
	BulkAddToTopicWorkerWhitelist(context.Context, *BulkAddToTopicWorkerWhitelistRequest) (*BulkAddToTopicWorkerWhitelistResponse, error)
	BulkRemoveFromTopicWorkerWhitelist(context.Context, *BulkRemoveFromTopicWorkerWhitelistRequest) (*BulkRemoveFromTopicWorkerWhitelistResponse, error)
	BulkAddToTopicReputerWhitelist(context.Context, *BulkAddToTopicReputerWhitelistRequest) (*BulkAddToTopicReputerWhitelistResponse, error)
	BulkRemoveFromTopicReputerWhitelist(context.Context, *BulkRemoveFromTopicReputerWhitelistRequest) (*BulkRemoveFromTopicReputerWhitelistResponse, error)
	EnableTopicWorkerWhitelist(context.Context, *EnableTopicWorkerWhitelistRequest) (*EnableTopicWorkerWhitelistResponse, error)
	DisableTopicWorkerWhitelist(context.Context, *DisableTopicWorkerWhitelistRequest) (*DisableTopicWorkerWhitelistResponse, error)
	EnableTopicReputerWhitelist(context.Context, *EnableTopicReputerWhitelistRequest) (*EnableTopicReputerWhitelistResponse, error)
	DisableTopicReputerWhitelist(context.Context, *DisableTopicReputerWhitelistRequest) (*DisableTopicReputerWhitelistResponse, error)
	AddToTopicCreatorWhitelist(context.Context, *AddToTopicCreatorWhitelistRequest) (*AddToTopicCreatorWhitelistResponse, error)
	RemoveFromTopicCreatorWhitelist(context.Context, *RemoveFromTopicCreatorWhitelistRequest) (*RemoveFromTopicCreatorWhitelistResponse, error)
	AddToTopicWorkerWhitelist(context.Context, *AddToTopicWorkerWhitelistRequest) (*AddToTopicWorkerWhitelistResponse, error)
	RemoveFromTopicWorkerWhitelist(context.Context, *RemoveFromTopicWorkerWhitelistRequest) (*RemoveFromTopicWorkerWhitelistResponse, error)
	AddToTopicReputerWhitelist(context.Context, *AddToTopicReputerWhitelistRequest) (*AddToTopicReputerWhitelistResponse, error)
	RemoveFromTopicReputerWhitelist(context.Context, *RemoveFromTopicReputerWhitelistRequest) (*RemoveFromTopicReputerWhitelistResponse, error)
}

// UnimplementedMsgServiceServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServiceServer struct {
}

func (*UnimplementedMsgServiceServer) UpdateParams(ctx context.Context, req *UpdateParamsRequest) (*UpdateParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}
func (*UnimplementedMsgServiceServer) CreateNewTopic(ctx context.Context, req *CreateNewTopicRequest) (*CreateNewTopicResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateNewTopic not implemented")
}
func (*UnimplementedMsgServiceServer) Register(ctx context.Context, req *RegisterRequest) (*RegisterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveRegistration(ctx context.Context, req *RemoveRegistrationRequest) (*RemoveRegistrationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveRegistration not implemented")
}
func (*UnimplementedMsgServiceServer) AddStake(ctx context.Context, req *AddStakeRequest) (*AddStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddStake not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveStake(ctx context.Context, req *RemoveStakeRequest) (*RemoveStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveStake not implemented")
}
func (*UnimplementedMsgServiceServer) CancelRemoveStake(ctx context.Context, req *CancelRemoveStakeRequest) (*CancelRemoveStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelRemoveStake not implemented")
}
func (*UnimplementedMsgServiceServer) DelegateStake(ctx context.Context, req *DelegateStakeRequest) (*DelegateStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateStake not implemented")
}
func (*UnimplementedMsgServiceServer) RewardDelegateStake(ctx context.Context, req *RewardDelegateStakeRequest) (*RewardDelegateStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RewardDelegateStake not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveDelegateStake(ctx context.Context, req *RemoveDelegateStakeRequest) (*RemoveDelegateStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveDelegateStake not implemented")
}
func (*UnimplementedMsgServiceServer) CancelRemoveDelegateStake(ctx context.Context, req *CancelRemoveDelegateStakeRequest) (*CancelRemoveDelegateStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelRemoveDelegateStake not implemented")
}
func (*UnimplementedMsgServiceServer) FundTopic(ctx context.Context, req *FundTopicRequest) (*FundTopicResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FundTopic not implemented")
}
func (*UnimplementedMsgServiceServer) AddToWhitelistAdmin(ctx context.Context, req *AddToWhitelistAdminRequest) (*AddToWhitelistAdminResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToWhitelistAdmin not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromWhitelistAdmin(ctx context.Context, req *RemoveFromWhitelistAdminRequest) (*RemoveFromWhitelistAdminResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromWhitelistAdmin not implemented")
}
func (*UnimplementedMsgServiceServer) InsertWorkerPayload(ctx context.Context, req *InsertWorkerPayloadRequest) (*InsertWorkerPayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertWorkerPayload not implemented")
}
func (*UnimplementedMsgServiceServer) InsertReputerPayload(ctx context.Context, req *InsertReputerPayloadRequest) (*InsertReputerPayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertReputerPayload not implemented")
}
func (*UnimplementedMsgServiceServer) AddToGlobalWhitelist(ctx context.Context, req *AddToGlobalWhitelistRequest) (*AddToGlobalWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToGlobalWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromGlobalWhitelist(ctx context.Context, req *RemoveFromGlobalWhitelistRequest) (*RemoveFromGlobalWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromGlobalWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToGlobalWorkerWhitelist(ctx context.Context, req *AddToGlobalWorkerWhitelistRequest) (*AddToGlobalWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToGlobalWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromGlobalWorkerWhitelist(ctx context.Context, req *RemoveFromGlobalWorkerWhitelistRequest) (*RemoveFromGlobalWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromGlobalWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToGlobalReputerWhitelist(ctx context.Context, req *AddToGlobalReputerWhitelistRequest) (*AddToGlobalReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToGlobalReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromGlobalReputerWhitelist(ctx context.Context, req *RemoveFromGlobalReputerWhitelistRequest) (*RemoveFromGlobalReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromGlobalReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToGlobalAdminWhitelist(ctx context.Context, req *AddToGlobalAdminWhitelistRequest) (*AddToGlobalAdminWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToGlobalAdminWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromGlobalAdminWhitelist(ctx context.Context, req *RemoveFromGlobalAdminWhitelistRequest) (*RemoveFromGlobalAdminWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromGlobalAdminWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkAddToGlobalWorkerWhitelist(ctx context.Context, req *BulkAddToGlobalWorkerWhitelistRequest) (*BulkAddToGlobalWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkAddToGlobalWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkRemoveFromGlobalWorkerWhitelist(ctx context.Context, req *BulkRemoveFromGlobalWorkerWhitelistRequest) (*BulkRemoveFromGlobalWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkRemoveFromGlobalWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkAddToGlobalReputerWhitelist(ctx context.Context, req *BulkAddToGlobalReputerWhitelistRequest) (*BulkAddToGlobalReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkAddToGlobalReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkRemoveFromGlobalReputerWhitelist(ctx context.Context, req *BulkRemoveFromGlobalReputerWhitelistRequest) (*BulkRemoveFromGlobalReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkRemoveFromGlobalReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkAddToTopicWorkerWhitelist(ctx context.Context, req *BulkAddToTopicWorkerWhitelistRequest) (*BulkAddToTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkAddToTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkRemoveFromTopicWorkerWhitelist(ctx context.Context, req *BulkRemoveFromTopicWorkerWhitelistRequest) (*BulkRemoveFromTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkRemoveFromTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkAddToTopicReputerWhitelist(ctx context.Context, req *BulkAddToTopicReputerWhitelistRequest) (*BulkAddToTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkAddToTopicReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) BulkRemoveFromTopicReputerWhitelist(ctx context.Context, req *BulkRemoveFromTopicReputerWhitelistRequest) (*BulkRemoveFromTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkRemoveFromTopicReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) EnableTopicWorkerWhitelist(ctx context.Context, req *EnableTopicWorkerWhitelistRequest) (*EnableTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) DisableTopicWorkerWhitelist(ctx context.Context, req *DisableTopicWorkerWhitelistRequest) (*DisableTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) EnableTopicReputerWhitelist(ctx context.Context, req *EnableTopicReputerWhitelistRequest) (*EnableTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableTopicReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) DisableTopicReputerWhitelist(ctx context.Context, req *DisableTopicReputerWhitelistRequest) (*DisableTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableTopicReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToTopicCreatorWhitelist(ctx context.Context, req *AddToTopicCreatorWhitelistRequest) (*AddToTopicCreatorWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToTopicCreatorWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromTopicCreatorWhitelist(ctx context.Context, req *RemoveFromTopicCreatorWhitelistRequest) (*RemoveFromTopicCreatorWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromTopicCreatorWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToTopicWorkerWhitelist(ctx context.Context, req *AddToTopicWorkerWhitelistRequest) (*AddToTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromTopicWorkerWhitelist(ctx context.Context, req *RemoveFromTopicWorkerWhitelistRequest) (*RemoveFromTopicWorkerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromTopicWorkerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) AddToTopicReputerWhitelist(ctx context.Context, req *AddToTopicReputerWhitelistRequest) (*AddToTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToTopicReputerWhitelist not implemented")
}
func (*UnimplementedMsgServiceServer) RemoveFromTopicReputerWhitelist(ctx context.Context, req *RemoveFromTopicReputerWhitelistRequest) (*RemoveFromTopicReputerWhitelistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFromTopicReputerWhitelist not implemented")
}

func RegisterMsgServiceServer(s grpc1.Server, srv MsgServiceServer) {
	s.RegisterService(&_MsgService_serviceDesc, srv)
}

func _MsgService_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).UpdateParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/UpdateParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).UpdateParams(ctx, req.(*UpdateParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_CreateNewTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateNewTopicRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).CreateNewTopic(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/CreateNewTopic",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).CreateNewTopic(ctx, req.(*CreateNewTopicRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/Register",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).Register(ctx, req.(*RegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveRegistration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveRegistrationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveRegistration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveRegistration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveRegistration(ctx, req.(*RemoveRegistrationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddStake(ctx, req.(*AddStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveStake(ctx, req.(*RemoveStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_CancelRemoveStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelRemoveStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).CancelRemoveStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/CancelRemoveStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).CancelRemoveStake(ctx, req.(*CancelRemoveStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_DelegateStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).DelegateStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/DelegateStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).DelegateStake(ctx, req.(*DelegateStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RewardDelegateStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RewardDelegateStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RewardDelegateStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RewardDelegateStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RewardDelegateStake(ctx, req.(*RewardDelegateStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveDelegateStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveDelegateStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveDelegateStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveDelegateStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveDelegateStake(ctx, req.(*RemoveDelegateStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_CancelRemoveDelegateStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelRemoveDelegateStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).CancelRemoveDelegateStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/CancelRemoveDelegateStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).CancelRemoveDelegateStake(ctx, req.(*CancelRemoveDelegateStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_FundTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FundTopicRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).FundTopic(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/FundTopic",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).FundTopic(ctx, req.(*FundTopicRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToWhitelistAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToWhitelistAdminRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToWhitelistAdmin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToWhitelistAdmin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToWhitelistAdmin(ctx, req.(*AddToWhitelistAdminRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromWhitelistAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromWhitelistAdminRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromWhitelistAdmin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromWhitelistAdmin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromWhitelistAdmin(ctx, req.(*RemoveFromWhitelistAdminRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_InsertWorkerPayload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertWorkerPayloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).InsertWorkerPayload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/InsertWorkerPayload",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).InsertWorkerPayload(ctx, req.(*InsertWorkerPayloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_InsertReputerPayload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertReputerPayloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).InsertReputerPayload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/InsertReputerPayload",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).InsertReputerPayload(ctx, req.(*InsertReputerPayloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToGlobalWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToGlobalWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToGlobalWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToGlobalWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToGlobalWhitelist(ctx, req.(*AddToGlobalWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromGlobalWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromGlobalWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromGlobalWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromGlobalWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromGlobalWhitelist(ctx, req.(*RemoveFromGlobalWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToGlobalWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToGlobalWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToGlobalWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToGlobalWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToGlobalWorkerWhitelist(ctx, req.(*AddToGlobalWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromGlobalWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromGlobalWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromGlobalWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromGlobalWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromGlobalWorkerWhitelist(ctx, req.(*RemoveFromGlobalWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToGlobalReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToGlobalReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToGlobalReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToGlobalReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToGlobalReputerWhitelist(ctx, req.(*AddToGlobalReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromGlobalReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromGlobalReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromGlobalReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromGlobalReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromGlobalReputerWhitelist(ctx, req.(*RemoveFromGlobalReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToGlobalAdminWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToGlobalAdminWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToGlobalAdminWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToGlobalAdminWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToGlobalAdminWhitelist(ctx, req.(*AddToGlobalAdminWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromGlobalAdminWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromGlobalAdminWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromGlobalAdminWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromGlobalAdminWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromGlobalAdminWhitelist(ctx, req.(*RemoveFromGlobalAdminWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkAddToGlobalWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkAddToGlobalWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkAddToGlobalWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkAddToGlobalWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkAddToGlobalWorkerWhitelist(ctx, req.(*BulkAddToGlobalWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkRemoveFromGlobalWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkRemoveFromGlobalWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkRemoveFromGlobalWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkRemoveFromGlobalWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkRemoveFromGlobalWorkerWhitelist(ctx, req.(*BulkRemoveFromGlobalWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkAddToGlobalReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkAddToGlobalReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkAddToGlobalReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkAddToGlobalReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkAddToGlobalReputerWhitelist(ctx, req.(*BulkAddToGlobalReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkRemoveFromGlobalReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkRemoveFromGlobalReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkRemoveFromGlobalReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkRemoveFromGlobalReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkRemoveFromGlobalReputerWhitelist(ctx, req.(*BulkRemoveFromGlobalReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkAddToTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkAddToTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkAddToTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkAddToTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkAddToTopicWorkerWhitelist(ctx, req.(*BulkAddToTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkRemoveFromTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkRemoveFromTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkRemoveFromTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkRemoveFromTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkRemoveFromTopicWorkerWhitelist(ctx, req.(*BulkRemoveFromTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkAddToTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkAddToTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkAddToTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkAddToTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkAddToTopicReputerWhitelist(ctx, req.(*BulkAddToTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_BulkRemoveFromTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BulkRemoveFromTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).BulkRemoveFromTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/BulkRemoveFromTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).BulkRemoveFromTopicReputerWhitelist(ctx, req.(*BulkRemoveFromTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_EnableTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).EnableTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/EnableTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).EnableTopicWorkerWhitelist(ctx, req.(*EnableTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_DisableTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).DisableTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/DisableTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).DisableTopicWorkerWhitelist(ctx, req.(*DisableTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_EnableTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).EnableTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/EnableTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).EnableTopicReputerWhitelist(ctx, req.(*EnableTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_DisableTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).DisableTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/DisableTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).DisableTopicReputerWhitelist(ctx, req.(*DisableTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToTopicCreatorWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToTopicCreatorWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToTopicCreatorWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToTopicCreatorWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToTopicCreatorWhitelist(ctx, req.(*AddToTopicCreatorWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromTopicCreatorWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromTopicCreatorWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromTopicCreatorWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromTopicCreatorWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromTopicCreatorWhitelist(ctx, req.(*RemoveFromTopicCreatorWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToTopicWorkerWhitelist(ctx, req.(*AddToTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromTopicWorkerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromTopicWorkerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromTopicWorkerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromTopicWorkerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromTopicWorkerWhitelist(ctx, req.(*RemoveFromTopicWorkerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_AddToTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddToTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).AddToTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/AddToTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).AddToTopicReputerWhitelist(ctx, req.(*AddToTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MsgService_RemoveFromTopicReputerWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFromTopicReputerWhitelistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServiceServer).RemoveFromTopicReputerWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/emissions.v9.MsgService/RemoveFromTopicReputerWhitelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServiceServer).RemoveFromTopicReputerWhitelist(ctx, req.(*RemoveFromTopicReputerWhitelistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var MsgService_serviceDesc = _MsgService_serviceDesc
var _MsgService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "emissions.v9.MsgService",
	HandlerType: (*MsgServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateParams",
			Handler:    _MsgService_UpdateParams_Handler,
		},
		{
			MethodName: "CreateNewTopic",
			Handler:    _MsgService_CreateNewTopic_Handler,
		},
		{
			MethodName: "Register",
			Handler:    _MsgService_Register_Handler,
		},
		{
			MethodName: "RemoveRegistration",
			Handler:    _MsgService_RemoveRegistration_Handler,
		},
		{
			MethodName: "AddStake",
			Handler:    _MsgService_AddStake_Handler,
		},
		{
			MethodName: "RemoveStake",
			Handler:    _MsgService_RemoveStake_Handler,
		},
		{
			MethodName: "CancelRemoveStake",
			Handler:    _MsgService_CancelRemoveStake_Handler,
		},
		{
			MethodName: "DelegateStake",
			Handler:    _MsgService_DelegateStake_Handler,
		},
		{
			MethodName: "RewardDelegateStake",
			Handler:    _MsgService_RewardDelegateStake_Handler,
		},
		{
			MethodName: "RemoveDelegateStake",
			Handler:    _MsgService_RemoveDelegateStake_Handler,
		},
		{
			MethodName: "CancelRemoveDelegateStake",
			Handler:    _MsgService_CancelRemoveDelegateStake_Handler,
		},
		{
			MethodName: "FundTopic",
			Handler:    _MsgService_FundTopic_Handler,
		},
		{
			MethodName: "AddToWhitelistAdmin",
			Handler:    _MsgService_AddToWhitelistAdmin_Handler,
		},
		{
			MethodName: "RemoveFromWhitelistAdmin",
			Handler:    _MsgService_RemoveFromWhitelistAdmin_Handler,
		},
		{
			MethodName: "InsertWorkerPayload",
			Handler:    _MsgService_InsertWorkerPayload_Handler,
		},
		{
			MethodName: "InsertReputerPayload",
			Handler:    _MsgService_InsertReputerPayload_Handler,
		},
		{
			MethodName: "AddToGlobalWhitelist",
			Handler:    _MsgService_AddToGlobalWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromGlobalWhitelist",
			Handler:    _MsgService_RemoveFromGlobalWhitelist_Handler,
		},
		{
			MethodName: "AddToGlobalWorkerWhitelist",
			Handler:    _MsgService_AddToGlobalWorkerWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromGlobalWorkerWhitelist",
			Handler:    _MsgService_RemoveFromGlobalWorkerWhitelist_Handler,
		},
		{
			MethodName: "AddToGlobalReputerWhitelist",
			Handler:    _MsgService_AddToGlobalReputerWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromGlobalReputerWhitelist",
			Handler:    _MsgService_RemoveFromGlobalReputerWhitelist_Handler,
		},
		{
			MethodName: "AddToGlobalAdminWhitelist",
			Handler:    _MsgService_AddToGlobalAdminWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromGlobalAdminWhitelist",
			Handler:    _MsgService_RemoveFromGlobalAdminWhitelist_Handler,
		},
		{
			MethodName: "BulkAddToGlobalWorkerWhitelist",
			Handler:    _MsgService_BulkAddToGlobalWorkerWhitelist_Handler,
		},
		{
			MethodName: "BulkRemoveFromGlobalWorkerWhitelist",
			Handler:    _MsgService_BulkRemoveFromGlobalWorkerWhitelist_Handler,
		},
		{
			MethodName: "BulkAddToGlobalReputerWhitelist",
			Handler:    _MsgService_BulkAddToGlobalReputerWhitelist_Handler,
		},
		{
			MethodName: "BulkRemoveFromGlobalReputerWhitelist",
			Handler:    _MsgService_BulkRemoveFromGlobalReputerWhitelist_Handler,
		},
		{
			MethodName: "BulkAddToTopicWorkerWhitelist",
			Handler:    _MsgService_BulkAddToTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "BulkRemoveFromTopicWorkerWhitelist",
			Handler:    _MsgService_BulkRemoveFromTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "BulkAddToTopicReputerWhitelist",
			Handler:    _MsgService_BulkAddToTopicReputerWhitelist_Handler,
		},
		{
			MethodName: "BulkRemoveFromTopicReputerWhitelist",
			Handler:    _MsgService_BulkRemoveFromTopicReputerWhitelist_Handler,
		},
		{
			MethodName: "EnableTopicWorkerWhitelist",
			Handler:    _MsgService_EnableTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "DisableTopicWorkerWhitelist",
			Handler:    _MsgService_DisableTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "EnableTopicReputerWhitelist",
			Handler:    _MsgService_EnableTopicReputerWhitelist_Handler,
		},
		{
			MethodName: "DisableTopicReputerWhitelist",
			Handler:    _MsgService_DisableTopicReputerWhitelist_Handler,
		},
		{
			MethodName: "AddToTopicCreatorWhitelist",
			Handler:    _MsgService_AddToTopicCreatorWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromTopicCreatorWhitelist",
			Handler:    _MsgService_RemoveFromTopicCreatorWhitelist_Handler,
		},
		{
			MethodName: "AddToTopicWorkerWhitelist",
			Handler:    _MsgService_AddToTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromTopicWorkerWhitelist",
			Handler:    _MsgService_RemoveFromTopicWorkerWhitelist_Handler,
		},
		{
			MethodName: "AddToTopicReputerWhitelist",
			Handler:    _MsgService_AddToTopicReputerWhitelist_Handler,
		},
		{
			MethodName: "RemoveFromTopicReputerWhitelist",
			Handler:    _MsgService_RemoveFromTopicReputerWhitelist_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "emissions/v9/tx.proto",
}

func (m *OptionalParams) 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 *OptionalParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OptionalParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MinWeightThresholdForStdnorm) > 0 {
		for iNdEx := len(m.MinWeightThresholdForStdnorm) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.MinWeightThresholdForStdnorm[iNdEx].Size()
				i -= size
				if _, err := m.MinWeightThresholdForStdnorm[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.MaxWhitelistInputArrayLength) > 0 {
		dAtA2 := make([]byte, len(m.MaxWhitelistInputArrayLength)*10)
		var j1 int
		for _, num := range m.MaxWhitelistInputArrayLength {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintTx(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xda
	}
	if len(m.GlobalAdminWhitelistAppended) > 0 {
		for iNdEx := len(m.GlobalAdminWhitelistAppended) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.GlobalAdminWhitelistAppended[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTx(dAtA, i, uint64(len(m.GlobalAdminWhitelistAppended)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xd2
	}
	if len(m.GlobalReputerWhitelistEnabled) > 0 {
		for iNdEx := len(m.GlobalReputerWhitelistEnabled) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.GlobalReputerWhitelistEnabled[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTx(dAtA, i, uint64(len(m.GlobalReputerWhitelistEnabled)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xca
	}
	if len(m.GlobalWorkerWhitelistEnabled) > 0 {
		for iNdEx := len(m.GlobalWorkerWhitelistEnabled) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.GlobalWorkerWhitelistEnabled[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTx(dAtA, i, uint64(len(m.GlobalWorkerWhitelistEnabled)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xc2
	}
	if len(m.LambdaInitialScore) > 0 {
		for iNdEx := len(m.LambdaInitialScore) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.LambdaInitialScore[iNdEx].Size()
				i -= size
				if _, err := m.LambdaInitialScore[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.InferenceOutlierDetectionAlpha) > 0 {
		for iNdEx := len(m.InferenceOutlierDetectionAlpha) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.InferenceOutlierDetectionAlpha[iNdEx].Size()
				i -= size
				if _, err := m.InferenceOutlierDetectionAlpha[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.InferenceOutlierDetectionThreshold) > 0 {
		for iNdEx := len(m.InferenceOutlierDetectionThreshold) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.InferenceOutlierDetectionThreshold[iNdEx].Size()
				i -= size
				if _, err := m.InferenceOutlierDetectionThreshold[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.MinExperiencedWorkerRegrets) > 0 {
		dAtA4 := make([]byte, len(m.MinExperiencedWorkerRegrets)*10)
		var j3 int
		for _, num := range m.MinExperiencedWorkerRegrets {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintTx(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xa2
	}
	if len(m.TopicCreatorWhitelistEnabled) > 0 {
		for iNdEx := len(m.TopicCreatorWhitelistEnabled) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.TopicCreatorWhitelistEnabled[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTx(dAtA, i, uint64(len(m.TopicCreatorWhitelistEnabled)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	if len(m.GlobalWhitelistEnabled) > 0 {
		for iNdEx := len(m.GlobalWhitelistEnabled) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.GlobalWhitelistEnabled[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTx(dAtA, i, uint64(len(m.GlobalWhitelistEnabled)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x92
	}
	if len(m.PNormSafeDiv) > 0 {
		for iNdEx := len(m.PNormSafeDiv) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.PNormSafeDiv[iNdEx].Size()
				i -= size
				if _, err := m.PNormSafeDiv[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.InitialRegretQuantile) > 0 {
		for iNdEx := len(m.InitialRegretQuantile) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.InitialRegretQuantile[iNdEx].Size()
				i -= size
				if _, err := m.InitialRegretQuantile[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.MaxStringLength) > 0 {
		dAtA6 := make([]byte, len(m.MaxStringLength)*10)
		var j5 int
		for _, num := range m.MaxStringLength {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintTx(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xfa
	}
	if len(m.MaxActiveTopicsPerBlock) > 0 {
		dAtA8 := make([]byte, len(m.MaxActiveTopicsPerBlock)*10)
		var j7 int
		for _, num := range m.MaxActiveTopicsPerBlock {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintTx(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf2
	}
	if len(m.MaxElementsPerForecast) > 0 {
		dAtA10 := make([]byte, len(m.MaxElementsPerForecast)*10)
		var j9 int
		for _, num := range m.MaxElementsPerForecast {
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		i -= j9
		copy(dAtA[i:], dAtA10[:j9])
		i = encodeVarintTx(dAtA, i, uint64(j9))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xea
	}
	if len(m.EpsilonSafeDiv) > 0 {
		for iNdEx := len(m.EpsilonSafeDiv) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.EpsilonSafeDiv[iNdEx].Size()
				i -= size
				if _, err := m.EpsilonSafeDiv[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.DataSendingFee) > 0 {
		for iNdEx := len(m.DataSendingFee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.DataSendingFee[iNdEx].Size()
				i -= size
				if _, err := m.DataSendingFee[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xda
		}
	}
	if len(m.HalfMaxProcessStakeRemovalsEndBlock) > 0 {
		dAtA12 := make([]byte, len(m.HalfMaxProcessStakeRemovalsEndBlock)*10)
		var j11 int
		for _, num := range m.HalfMaxProcessStakeRemovalsEndBlock {
			for num >= 1<<7 {
				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j11++
			}
			dAtA12[j11] = uint8(num)
			j11++
		}
		i -= j11
		copy(dAtA[i:], dAtA12[:j11])
		i = encodeVarintTx(dAtA, i, uint64(j11))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd2
	}
	if len(m.EpsilonReputer) > 0 {
		for iNdEx := len(m.EpsilonReputer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.EpsilonReputer[iNdEx].Size()
				i -= size
				if _, err := m.EpsilonReputer[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.CNorm) > 0 {
		for iNdEx := len(m.CNorm) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.CNorm[iNdEx].Size()
				i -= size
				if _, err := m.CNorm[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.CRewardForecast) > 0 {
		for iNdEx := len(m.CRewardForecast) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.CRewardForecast[iNdEx].Size()
				i -= size
				if _, err := m.CRewardForecast[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.CRewardInference) > 0 {
		for iNdEx := len(m.CRewardInference) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.CRewardInference[iNdEx].Size()
				i -= size
				if _, err := m.CRewardInference[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.PRewardReputer) > 0 {
		for iNdEx := len(m.PRewardReputer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.PRewardReputer[iNdEx].Size()
				i -= size
				if _, err := m.PRewardReputer[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.PRewardForecast) > 0 {
		for iNdEx := len(m.PRewardForecast) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.PRewardForecast[iNdEx].Size()
				i -= size
				if _, err := m.PRewardForecast[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.PRewardInference) > 0 {
		for iNdEx := len(m.PRewardInference) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.PRewardInference[iNdEx].Size()
				i -= size
				if _, err := m.PRewardInference[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.BlocksPerMonth) > 0 {
		dAtA14 := make([]byte, len(m.BlocksPerMonth)*10)
		var j13 int
		for _, num := range m.BlocksPerMonth {
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		i -= j13
		copy(dAtA[i:], dAtA14[:j13])
		i = encodeVarintTx(dAtA, i, uint64(j13))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x82
	}
	if len(m.MinEpochLengthRecordLimit) > 0 {
		dAtA16 := make([]byte, len(m.MinEpochLengthRecordLimit)*10)
		var j15 int
		for _, num1 := range m.MinEpochLengthRecordLimit {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		i -= j15
		copy(dAtA[i:], dAtA16[:j15])
		i = encodeVarintTx(dAtA, i, uint64(j15))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfa
	}
	if len(m.MaxPageLimit) > 0 {
		dAtA18 := make([]byte, len(m.MaxPageLimit)*10)
		var j17 int
		for _, num := range m.MaxPageLimit {
			for num >= 1<<7 {
				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j17++
			}
			dAtA18[j17] = uint8(num)
			j17++
		}
		i -= j17
		copy(dAtA[i:], dAtA18[:j17])
		i = encodeVarintTx(dAtA, i, uint64(j17))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	if len(m.DefaultPageLimit) > 0 {
		dAtA20 := make([]byte, len(m.DefaultPageLimit)*10)
		var j19 int
		for _, num := range m.DefaultPageLimit {
			for num >= 1<<7 {
				dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j19++
			}
			dAtA20[j19] = uint8(num)
			j19++
		}
		i -= j19
		copy(dAtA[i:], dAtA20[:j19])
		i = encodeVarintTx(dAtA, i, uint64(j19))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xea
	}
	if len(m.RegistrationFee) > 0 {
		for iNdEx := len(m.RegistrationFee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.RegistrationFee[iNdEx].Size()
				i -= size
				if _, err := m.RegistrationFee[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.GradientDescentMaxIters) > 0 {
		dAtA22 := make([]byte, len(m.GradientDescentMaxIters)*10)
		var j21 int
		for _, num := range m.GradientDescentMaxIters {
			for num >= 1<<7 {
				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j21++
			}
			dAtA22[j21] = uint8(num)
			j21++
		}
		i -= j21
		copy(dAtA[i:], dAtA22[:j21])
		i = encodeVarintTx(dAtA, i, uint64(j21))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	if len(m.CreateTopicFee) > 0 {
		for iNdEx := len(m.CreateTopicFee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.CreateTopicFee[iNdEx].Size()
				i -= size
				if _, err := m.CreateTopicFee[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.MaxTopReputersToReward) > 0 {
		dAtA24 := make([]byte, len(m.MaxTopReputersToReward)*10)
		var j23 int
		for _, num := range m.MaxTopReputersToReward {
			for num >= 1<<7 {
				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j23++
			}
			dAtA24[j23] = uint8(num)
			j23++
		}
		i -= j23
		copy(dAtA[i:], dAtA24[:j23])
		i = encodeVarintTx(dAtA, i, uint64(j23))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	if len(m.MaxTopForecastersToReward) > 0 {
		dAtA26 := make([]byte, len(m.MaxTopForecastersToReward)*10)
		var j25 int
		for _, num := range m.MaxTopForecastersToReward {
			for num >= 1<<7 {
				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j25++
			}
			dAtA26[j25] = uint8(num)
			j25++
		}
		i -= j25
		copy(dAtA[i:], dAtA26[:j25])
		i = encodeVarintTx(dAtA, i, uint64(j25))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	if len(m.MaxTopInferersToReward) > 0 {
		dAtA28 := make([]byte, len(m.MaxTopInferersToReward)*10)
		var j27 int
		for _, num := range m.MaxTopInferersToReward {
			for num >= 1<<7 {
				dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j27++
			}
			dAtA28[j27] = uint8(num)
			j27++
		}
		i -= j27
		copy(dAtA[i:], dAtA28[:j27])
		i = encodeVarintTx(dAtA, i, uint64(j27))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.MaxSamplesToScaleScores) > 0 {
		dAtA30 := make([]byte, len(m.MaxSamplesToScaleScores)*10)
		var j29 int
		for _, num := range m.MaxSamplesToScaleScores {
			for num >= 1<<7 {
				dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j29++
			}
			dAtA30[j29] = uint8(num)
			j29++
		}
		i -= j29
		copy(dAtA[i:], dAtA30[:j29])
		i = encodeVarintTx(dAtA, i, uint64(j29))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.ValidatorsVsAlloraPercentReward) > 0 {
		for iNdEx := len(m.ValidatorsVsAlloraPercentReward) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.ValidatorsVsAlloraPercentReward[iNdEx].Size()
				i -= size
				if _, err := m.ValidatorsVsAlloraPercentReward[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.TaskRewardAlpha) > 0 {
		for iNdEx := len(m.TaskRewardAlpha) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.TaskRewardAlpha[iNdEx].Size()
				i -= size
				if _, err := m.TaskRewardAlpha[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.TopicRewardAlpha) > 0 {
		for iNdEx := len(m.TopicRewardAlpha) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.TopicRewardAlpha[iNdEx].Size()
				i -= size
				if _, err := m.TopicRewardAlpha[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.TopicRewardFeeRevenueImportance) > 0 {
		for iNdEx := len(m.TopicRewardFeeRevenueImportance) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.TopicRewardFeeRevenueImportance[iNdEx].Size()
				i -= size
				if _, err := m.TopicRewardFeeRevenueImportance[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.TopicRewardStakeImportance) > 0 {
		for iNdEx := len(m.TopicRewardStakeImportance) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.TopicRewardStakeImportance[iNdEx].Size()
				i -= size
				if _, err := m.TopicRewardStakeImportance[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.MaxUnfulfilledReputerRequests) > 0 {
		dAtA32 := make([]byte, len(m.MaxUnfulfilledReputerRequests)*10)
		var j31 int
		for _, num := range m.MaxUnfulfilledReputerRequests {
			for num >= 1<<7 {
				dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j31++
			}
			dAtA32[j31] = uint8(num)
			j31++
		}
		i -= j31
		copy(dAtA[i:], dAtA32[:j31])
		i = encodeVarintTx(dAtA, i, uint64(j31))
		i--
		dAtA[i] = 0x72
	}
	if len(m.MaxUnfulfilledWorkerRequests) > 0 {
		dAtA34 := make([]byte, len(m.MaxUnfulfilledWorkerRequests)*10)
		var j33 int
		for _, num := range m.MaxUnfulfilledWorkerRequests {
			for num >= 1<<7 {
				dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j33++
			}
			dAtA34[j33] = uint8(num)
			j33++
		}
		i -= j33
		copy(dAtA[i:], dAtA34[:j33])
		i = encodeVarintTx(dAtA, i, uint64(j33))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.MinStakeFraction) > 0 {
		for iNdEx := len(m.MinStakeFraction) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.MinStakeFraction[iNdEx].Size()
				i -= size
				if _, err := m.MinStakeFraction[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.MaxGradientThreshold) > 0 {
		for iNdEx := len(m.MaxGradientThreshold) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.MaxGradientThreshold[iNdEx].Size()
				i -= size
				if _, err := m.MaxGradientThreshold[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.LearningRate) > 0 {
		for iNdEx := len(m.LearningRate) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.LearningRate[iNdEx].Size()
				i -= size
				if _, err := m.LearningRate[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.BetaEntropy) > 0 {
		for iNdEx := len(m.BetaEntropy) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.BetaEntropy[iNdEx].Size()
				i -= size
				if _, err := m.BetaEntropy[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.MinEpochLength) > 0 {
		dAtA36 := make([]byte, len(m.MinEpochLength)*10)
		var j35 int
		for _, num1 := range m.MinEpochLength {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j35++
			}
			dAtA36[j35] = uint8(num)
			j35++
		}
		i -= j35
		copy(dAtA[i:], dAtA36[:j35])
		i = encodeVarintTx(dAtA, i, uint64(j35))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.RemoveStakeDelayWindow) > 0 {
		dAtA38 := make([]byte, len(m.RemoveStakeDelayWindow)*10)
		var j37 int
		for _, num1 := range m.RemoveStakeDelayWindow {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA38[j37] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j37++
			}
			dAtA38[j37] = uint8(num)
			j37++
		}
		i -= j37
		copy(dAtA[i:], dAtA38[:j37])
		i = encodeVarintTx(dAtA, i, uint64(j37))
		i--
		dAtA[i] = 0x32
	}
	if len(m.RequiredMinimumStake) > 0 {
		for iNdEx := len(m.RequiredMinimumStake) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.RequiredMinimumStake[iNdEx].Size()
				i -= size
				if _, err := m.RequiredMinimumStake[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.MinTopicWeight) > 0 {
		for iNdEx := len(m.MinTopicWeight) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.MinTopicWeight[iNdEx].Size()
				i -= size
				if _, err := m.MinTopicWeight[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.MaxSerializedMsgLength) > 0 {
		dAtA40 := make([]byte, len(m.MaxSerializedMsgLength)*10)
		var j39 int
		for _, num1 := range m.MaxSerializedMsgLength {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA40[j39] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j39++
			}
			dAtA40[j39] = uint8(num)
			j39++
		}
		i -= j39
		copy(dAtA[i:], dAtA40[:j39])
		i = encodeVarintTx(dAtA, i, uint64(j39))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Version) > 0 {
		for iNdEx := len(m.Version) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Version[iNdEx])
			copy(dAtA[i:], m.Version[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Version[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *UpdateParamsRequest) 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 *UpdateParamsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Params != nil {
		{
			size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateParamsResponse) 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 *UpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *CreateNewTopicRequest) 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 *CreateNewTopicRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateNewTopicRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EnableReputerWhitelist {
		i--
		if m.EnableReputerWhitelist {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.EnableWorkerWhitelist {
		i--
		if m.EnableWorkerWhitelist {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	{
		size := m.ActiveReputerQuantile.Size()
		i -= size
		if _, err := m.ActiveReputerQuantile.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	{
		size := m.ActiveForecasterQuantile.Size()
		i -= size
		if _, err := m.ActiveForecasterQuantile.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.ActiveInfererQuantile.Size()
		i -= size
		if _, err := m.ActiveInfererQuantile.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.MeritSortitionAlpha.Size()
		i -= size
		if _, err := m.MeritSortitionAlpha.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.WorkerSubmissionWindow != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.WorkerSubmissionWindow))
		i--
		dAtA[i] = 0x70
	}
	{
		size := m.Epsilon.Size()
		i -= size
		if _, err := m.Epsilon.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	if m.AllowNegative {
		i--
		if m.AllowNegative {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	{
		size := m.AlphaRegret.Size()
		i -= size
		if _, err := m.AlphaRegret.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size := m.PNorm.Size()
		i -= size
		if _, err := m.PNorm.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	if m.GroundTruthLag != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.GroundTruthLag))
		i--
		dAtA[i] = 0x40
	}
	if m.EpochLength != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.EpochLength))
		i--
		dAtA[i] = 0x38
	}
	if len(m.LossMethod) > 0 {
		i -= len(m.LossMethod)
		copy(dAtA[i:], m.LossMethod)
		i = encodeVarintTx(dAtA, i, uint64(len(m.LossMethod)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateNewTopicResponse) 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 *CreateNewTopicResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateNewTopicResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InsertReputerPayloadRequest) 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 *InsertReputerPayloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InsertReputerPayloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReputerValueBundle != nil {
		{
			size, err := m.ReputerValueBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InsertReputerPayloadResponse) 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 *InsertReputerPayloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InsertReputerPayloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *InsertWorkerPayloadRequest) 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 *InsertWorkerPayloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InsertWorkerPayloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.WorkerDataBundle != nil {
		{
			size, err := m.WorkerDataBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InsertWorkerPayloadResponse) 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 *InsertWorkerPayloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InsertWorkerPayloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RegisterRequest) 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 *RegisterRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsReputer {
		i--
		if m.IsReputer {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x2a
	}
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RegisterResponse) 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 *RegisterResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Success {
		i--
		if m.Success {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RemoveRegistrationRequest) 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 *RemoveRegistrationRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveRegistrationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsReputer {
		i--
		if m.IsReputer {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveRegistrationResponse) 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 *RemoveRegistrationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveRegistrationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Success {
		i--
		if m.Success {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AddStakeRequest) 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 *AddStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddStakeResponse) 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 *AddStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveStakeRequest) 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 *RemoveStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveStakeResponse) 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 *RemoveStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *CancelRemoveStakeRequest) 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 *CancelRemoveStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CancelRemoveStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CancelRemoveStakeResponse) 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 *CancelRemoveStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CancelRemoveStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DelegateStakeRequest) 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 *DelegateStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelegateStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DelegateStakeResponse) 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 *DelegateStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelegateStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveDelegateStakeRequest) 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 *RemoveDelegateStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveDelegateStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveDelegateStakeResponse) 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 *RemoveDelegateStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveDelegateStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *CancelRemoveDelegateStakeRequest) 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 *CancelRemoveDelegateStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CancelRemoveDelegateStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CancelRemoveDelegateStakeResponse) 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 *CancelRemoveDelegateStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CancelRemoveDelegateStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RewardDelegateStakeRequest) 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 *RewardDelegateStakeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RewardDelegateStakeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RewardDelegateStakeResponse) 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 *RewardDelegateStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RewardDelegateStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *FundTopicRequest) 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 *FundTopicRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundTopicRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FundTopicResponse) 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 *FundTopicResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundTopicResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToWhitelistAdminRequest) 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 *AddToWhitelistAdminRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToWhitelistAdminRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToWhitelistAdminResponse) 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 *AddToWhitelistAdminResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToWhitelistAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromWhitelistAdminRequest) 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 *RemoveFromWhitelistAdminRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromWhitelistAdminRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromWhitelistAdminResponse) 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 *RemoveFromWhitelistAdminResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromWhitelistAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EnableTopicWorkerWhitelistRequest) 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 *EnableTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnableTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnableTopicWorkerWhitelistResponse) 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 *EnableTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnableTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DisableTopicWorkerWhitelistRequest) 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 *DisableTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisableTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DisableTopicWorkerWhitelistResponse) 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 *DisableTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisableTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EnableTopicReputerWhitelistRequest) 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 *EnableTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnableTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnableTopicReputerWhitelistResponse) 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 *EnableTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnableTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DisableTopicReputerWhitelistRequest) 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 *DisableTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisableTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DisableTopicReputerWhitelistResponse) 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 *DisableTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisableTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToGlobalWhitelistRequest) 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 *AddToGlobalWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToGlobalWhitelistResponse) 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 *AddToGlobalWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalWhitelistRequest) 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 *RemoveFromGlobalWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalWhitelistResponse) 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 *RemoveFromGlobalWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToTopicCreatorWhitelistRequest) 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 *AddToTopicCreatorWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicCreatorWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToTopicCreatorWhitelistResponse) 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 *AddToTopicCreatorWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicCreatorWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToGlobalWorkerWhitelistRequest) 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 *AddToGlobalWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToGlobalWorkerWhitelistResponse) 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 *AddToGlobalWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalWorkerWhitelistRequest) 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 *RemoveFromGlobalWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalWorkerWhitelistResponse) 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 *RemoveFromGlobalWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToGlobalReputerWhitelistRequest) 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 *AddToGlobalReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToGlobalReputerWhitelistResponse) 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 *AddToGlobalReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalReputerWhitelistRequest) 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 *RemoveFromGlobalReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalReputerWhitelistResponse) 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 *RemoveFromGlobalReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToGlobalAdminWhitelistRequest) 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 *AddToGlobalAdminWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalAdminWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToGlobalAdminWhitelistResponse) 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 *AddToGlobalAdminWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToGlobalAdminWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalAdminWhitelistRequest) 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 *RemoveFromGlobalAdminWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalAdminWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromGlobalAdminWhitelistResponse) 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 *RemoveFromGlobalAdminWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromGlobalAdminWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkAddToGlobalWorkerWhitelistRequest) 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 *BulkAddToGlobalWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToGlobalWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkAddToGlobalWorkerWhitelistResponse) 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 *BulkAddToGlobalWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToGlobalWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) 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 *BulkRemoveFromGlobalWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) 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 *BulkRemoveFromGlobalWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkAddToGlobalReputerWhitelistRequest) 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 *BulkAddToGlobalReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToGlobalReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkAddToGlobalReputerWhitelistResponse) 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 *BulkAddToGlobalReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToGlobalReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) 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 *BulkRemoveFromGlobalReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromGlobalReputerWhitelistResponse) 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 *BulkRemoveFromGlobalReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromGlobalReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkAddToTopicWorkerWhitelistRequest) 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 *BulkAddToTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkAddToTopicWorkerWhitelistResponse) 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 *BulkAddToTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) 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 *BulkRemoveFromTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromTopicWorkerWhitelistResponse) 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 *BulkRemoveFromTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkAddToTopicReputerWhitelistRequest) 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 *BulkAddToTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkAddToTopicReputerWhitelistResponse) 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 *BulkAddToTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkAddToTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) 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 *BulkRemoveFromTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BulkRemoveFromTopicReputerWhitelistResponse) 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 *BulkRemoveFromTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BulkRemoveFromTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicCreatorWhitelistRequest) 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 *RemoveFromTopicCreatorWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicCreatorWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicCreatorWhitelistResponse) 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 *RemoveFromTopicCreatorWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicCreatorWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToTopicWorkerWhitelistRequest) 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 *AddToTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToTopicWorkerWhitelistResponse) 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 *AddToTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicWorkerWhitelistRequest) 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 *RemoveFromTopicWorkerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicWorkerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicWorkerWhitelistResponse) 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 *RemoveFromTopicWorkerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicWorkerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddToTopicReputerWhitelistRequest) 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 *AddToTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddToTopicReputerWhitelistResponse) 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 *AddToTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddToTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicReputerWhitelistRequest) 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 *RemoveFromTopicReputerWhitelistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicReputerWhitelistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveFromTopicReputerWhitelistResponse) 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 *RemoveFromTopicReputerWhitelistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveFromTopicReputerWhitelistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *OptionalParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Version) > 0 {
		for _, s := range m.Version {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.MaxSerializedMsgLength) > 0 {
		l = 0
		for _, e := range m.MaxSerializedMsgLength {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	if len(m.MinTopicWeight) > 0 {
		for _, e := range m.MinTopicWeight {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.RequiredMinimumStake) > 0 {
		for _, e := range m.RequiredMinimumStake {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.RemoveStakeDelayWindow) > 0 {
		l = 0
		for _, e := range m.RemoveStakeDelayWindow {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	if len(m.MinEpochLength) > 0 {
		l = 0
		for _, e := range m.MinEpochLength {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	if len(m.BetaEntropy) > 0 {
		for _, e := range m.BetaEntropy {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.LearningRate) > 0 {
		for _, e := range m.LearningRate {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.MaxGradientThreshold) > 0 {
		for _, e := range m.MaxGradientThreshold {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.MinStakeFraction) > 0 {
		for _, e := range m.MinStakeFraction {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.MaxUnfulfilledWorkerRequests) > 0 {
		l = 0
		for _, e := range m.MaxUnfulfilledWorkerRequests {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	if len(m.MaxUnfulfilledReputerRequests) > 0 {
		l = 0
		for _, e := range m.MaxUnfulfilledReputerRequests {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	if len(m.TopicRewardStakeImportance) > 0 {
		for _, e := range m.TopicRewardStakeImportance {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.TopicRewardFeeRevenueImportance) > 0 {
		for _, e := range m.TopicRewardFeeRevenueImportance {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.TopicRewardAlpha) > 0 {
		for _, e := range m.TopicRewardAlpha {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.TaskRewardAlpha) > 0 {
		for _, e := range m.TaskRewardAlpha {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.ValidatorsVsAlloraPercentReward) > 0 {
		for _, e := range m.ValidatorsVsAlloraPercentReward {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.MaxSamplesToScaleScores) > 0 {
		l = 0
		for _, e := range m.MaxSamplesToScaleScores {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxTopInferersToReward) > 0 {
		l = 0
		for _, e := range m.MaxTopInferersToReward {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxTopForecastersToReward) > 0 {
		l = 0
		for _, e := range m.MaxTopForecastersToReward {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxTopReputersToReward) > 0 {
		l = 0
		for _, e := range m.MaxTopReputersToReward {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.CreateTopicFee) > 0 {
		for _, e := range m.CreateTopicFee {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.GradientDescentMaxIters) > 0 {
		l = 0
		for _, e := range m.GradientDescentMaxIters {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.RegistrationFee) > 0 {
		for _, e := range m.RegistrationFee {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.DefaultPageLimit) > 0 {
		l = 0
		for _, e := range m.DefaultPageLimit {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxPageLimit) > 0 {
		l = 0
		for _, e := range m.MaxPageLimit {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MinEpochLengthRecordLimit) > 0 {
		l = 0
		for _, e := range m.MinEpochLengthRecordLimit {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.BlocksPerMonth) > 0 {
		l = 0
		for _, e := range m.BlocksPerMonth {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.PRewardInference) > 0 {
		for _, e := range m.PRewardInference {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.PRewardForecast) > 0 {
		for _, e := range m.PRewardForecast {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.PRewardReputer) > 0 {
		for _, e := range m.PRewardReputer {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.CRewardInference) > 0 {
		for _, e := range m.CRewardInference {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.CRewardForecast) > 0 {
		for _, e := range m.CRewardForecast {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.CNorm) > 0 {
		for _, e := range m.CNorm {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.EpsilonReputer) > 0 {
		for _, e := range m.EpsilonReputer {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.HalfMaxProcessStakeRemovalsEndBlock) > 0 {
		l = 0
		for _, e := range m.HalfMaxProcessStakeRemovalsEndBlock {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.DataSendingFee) > 0 {
		for _, e := range m.DataSendingFee {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.EpsilonSafeDiv) > 0 {
		for _, e := range m.EpsilonSafeDiv {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.MaxElementsPerForecast) > 0 {
		l = 0
		for _, e := range m.MaxElementsPerForecast {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxActiveTopicsPerBlock) > 0 {
		l = 0
		for _, e := range m.MaxActiveTopicsPerBlock {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MaxStringLength) > 0 {
		l = 0
		for _, e := range m.MaxStringLength {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.InitialRegretQuantile) > 0 {
		for _, e := range m.InitialRegretQuantile {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.PNormSafeDiv) > 0 {
		for _, e := range m.PNormSafeDiv {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.GlobalWhitelistEnabled) > 0 {
		n += 2 + sovTx(uint64(len(m.GlobalWhitelistEnabled))) + len(m.GlobalWhitelistEnabled)*1
	}
	if len(m.TopicCreatorWhitelistEnabled) > 0 {
		n += 2 + sovTx(uint64(len(m.TopicCreatorWhitelistEnabled))) + len(m.TopicCreatorWhitelistEnabled)*1
	}
	if len(m.MinExperiencedWorkerRegrets) > 0 {
		l = 0
		for _, e := range m.MinExperiencedWorkerRegrets {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.InferenceOutlierDetectionThreshold) > 0 {
		for _, e := range m.InferenceOutlierDetectionThreshold {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.InferenceOutlierDetectionAlpha) > 0 {
		for _, e := range m.InferenceOutlierDetectionAlpha {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.LambdaInitialScore) > 0 {
		for _, e := range m.LambdaInitialScore {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	if len(m.GlobalWorkerWhitelistEnabled) > 0 {
		n += 2 + sovTx(uint64(len(m.GlobalWorkerWhitelistEnabled))) + len(m.GlobalWorkerWhitelistEnabled)*1
	}
	if len(m.GlobalReputerWhitelistEnabled) > 0 {
		n += 2 + sovTx(uint64(len(m.GlobalReputerWhitelistEnabled))) + len(m.GlobalReputerWhitelistEnabled)*1
	}
	if len(m.GlobalAdminWhitelistAppended) > 0 {
		n += 2 + sovTx(uint64(len(m.GlobalAdminWhitelistAppended))) + len(m.GlobalAdminWhitelistAppended)*1
	}
	if len(m.MaxWhitelistInputArrayLength) > 0 {
		l = 0
		for _, e := range m.MaxWhitelistInputArrayLength {
			l += sovTx(uint64(e))
		}
		n += 2 + sovTx(uint64(l)) + l
	}
	if len(m.MinWeightThresholdForStdnorm) > 0 {
		for _, e := range m.MinWeightThresholdForStdnorm {
			l = e.Size()
			n += 2 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *UpdateParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Params != nil {
		l = m.Params.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *UpdateParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *CreateNewTopicRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.LossMethod)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.EpochLength != 0 {
		n += 1 + sovTx(uint64(m.EpochLength))
	}
	if m.GroundTruthLag != 0 {
		n += 1 + sovTx(uint64(m.GroundTruthLag))
	}
	l = m.PNorm.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.AlphaRegret.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.AllowNegative {
		n += 2
	}
	l = m.Epsilon.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.WorkerSubmissionWindow != 0 {
		n += 1 + sovTx(uint64(m.WorkerSubmissionWindow))
	}
	l = m.MeritSortitionAlpha.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.ActiveInfererQuantile.Size()
	n += 2 + l + sovTx(uint64(l))
	l = m.ActiveForecasterQuantile.Size()
	n += 2 + l + sovTx(uint64(l))
	l = m.ActiveReputerQuantile.Size()
	n += 2 + l + sovTx(uint64(l))
	if m.EnableWorkerWhitelist {
		n += 3
	}
	if m.EnableReputerWhitelist {
		n += 3
	}
	return n
}

func (m *CreateNewTopicResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *InsertReputerPayloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.ReputerValueBundle != nil {
		l = m.ReputerValueBundle.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *InsertReputerPayloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *InsertWorkerPayloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.WorkerDataBundle != nil {
		l = m.WorkerDataBundle.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *InsertWorkerPayloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RegisterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.IsReputer {
		n += 2
	}
	return n
}

func (m *RegisterResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Success {
		n += 2
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveRegistrationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	if m.IsReputer {
		n += 2
	}
	return n
}

func (m *RemoveRegistrationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Success {
		n += 2
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *AddStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *RemoveStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *CancelRemoveStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *CancelRemoveStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DelegateStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *DelegateStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveDelegateStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *RemoveDelegateStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *CancelRemoveDelegateStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *CancelRemoveDelegateStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RewardDelegateStakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RewardDelegateStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *FundTopicRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *FundTopicResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToWhitelistAdminRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToWhitelistAdminResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromWhitelistAdminRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromWhitelistAdminResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EnableTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *EnableTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DisableTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *DisableTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EnableTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *EnableTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DisableTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *DisableTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToGlobalWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToGlobalWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromGlobalWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromGlobalWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToTopicCreatorWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToTopicCreatorWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToGlobalWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToGlobalWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromGlobalWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromGlobalWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToGlobalReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToGlobalReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromGlobalReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromGlobalReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToGlobalAdminWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *AddToGlobalAdminWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromGlobalAdminWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromGlobalAdminWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkAddToGlobalWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *BulkAddToGlobalWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkAddToGlobalReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *BulkAddToGlobalReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkRemoveFromGlobalReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *BulkRemoveFromGlobalReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkAddToTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *BulkAddToTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkRemoveFromTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *BulkRemoveFromTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkAddToTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *BulkAddToTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BulkRemoveFromTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *BulkRemoveFromTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromTopicCreatorWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *RemoveFromTopicCreatorWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *AddToTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromTopicWorkerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *RemoveFromTopicWorkerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddToTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *AddToTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveFromTopicReputerWhitelistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovTx(uint64(m.TopicId))
	}
	return n
}

func (m *RemoveFromTopicReputerWhitelistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *OptionalParams) 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 ErrIntOverflowTx
			}
			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: OptionalParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OptionalParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = append(m.Version, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxSerializedMsgLength = append(m.MaxSerializedMsgLength, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxSerializedMsgLength) == 0 {
					m.MaxSerializedMsgLength = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxSerializedMsgLength = append(m.MaxSerializedMsgLength, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSerializedMsgLength", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinTopicWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.MinTopicWeight = append(m.MinTopicWeight, v)
			if err := m.MinTopicWeight[len(m.MinTopicWeight)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredMinimumStake", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.Int
			m.RequiredMinimumStake = append(m.RequiredMinimumStake, v)
			if err := m.RequiredMinimumStake[len(m.RequiredMinimumStake)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RemoveStakeDelayWindow = append(m.RemoveStakeDelayWindow, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RemoveStakeDelayWindow) == 0 {
					m.RemoveStakeDelayWindow = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RemoveStakeDelayWindow = append(m.RemoveStakeDelayWindow, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveStakeDelayWindow", wireType)
			}
		case 7:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MinEpochLength = append(m.MinEpochLength, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MinEpochLength) == 0 {
					m.MinEpochLength = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MinEpochLength = append(m.MinEpochLength, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MinEpochLength", wireType)
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BetaEntropy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.BetaEntropy = append(m.BetaEntropy, v)
			if err := m.BetaEntropy[len(m.BetaEntropy)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LearningRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.LearningRate = append(m.LearningRate, v)
			if err := m.LearningRate[len(m.LearningRate)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxGradientThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.MaxGradientThreshold = append(m.MaxGradientThreshold, v)
			if err := m.MaxGradientThreshold[len(m.MaxGradientThreshold)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinStakeFraction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.MinStakeFraction = append(m.MinStakeFraction, v)
			if err := m.MinStakeFraction[len(m.MinStakeFraction)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxUnfulfilledWorkerRequests = append(m.MaxUnfulfilledWorkerRequests, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxUnfulfilledWorkerRequests) == 0 {
					m.MaxUnfulfilledWorkerRequests = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxUnfulfilledWorkerRequests = append(m.MaxUnfulfilledWorkerRequests, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnfulfilledWorkerRequests", wireType)
			}
		case 14:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxUnfulfilledReputerRequests = append(m.MaxUnfulfilledReputerRequests, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxUnfulfilledReputerRequests) == 0 {
					m.MaxUnfulfilledReputerRequests = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxUnfulfilledReputerRequests = append(m.MaxUnfulfilledReputerRequests, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnfulfilledReputerRequests", wireType)
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardStakeImportance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.TopicRewardStakeImportance = append(m.TopicRewardStakeImportance, v)
			if err := m.TopicRewardStakeImportance[len(m.TopicRewardStakeImportance)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardFeeRevenueImportance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.TopicRewardFeeRevenueImportance = append(m.TopicRewardFeeRevenueImportance, v)
			if err := m.TopicRewardFeeRevenueImportance[len(m.TopicRewardFeeRevenueImportance)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.TopicRewardAlpha = append(m.TopicRewardAlpha, v)
			if err := m.TopicRewardAlpha[len(m.TopicRewardAlpha)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskRewardAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.TaskRewardAlpha = append(m.TaskRewardAlpha, v)
			if err := m.TaskRewardAlpha[len(m.TaskRewardAlpha)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsVsAlloraPercentReward", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.ValidatorsVsAlloraPercentReward = append(m.ValidatorsVsAlloraPercentReward, v)
			if err := m.ValidatorsVsAlloraPercentReward[len(m.ValidatorsVsAlloraPercentReward)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxSamplesToScaleScores = append(m.MaxSamplesToScaleScores, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxSamplesToScaleScores) == 0 {
					m.MaxSamplesToScaleScores = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxSamplesToScaleScores = append(m.MaxSamplesToScaleScores, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSamplesToScaleScores", wireType)
			}
		case 21:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxTopInferersToReward = append(m.MaxTopInferersToReward, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxTopInferersToReward) == 0 {
					m.MaxTopInferersToReward = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxTopInferersToReward = append(m.MaxTopInferersToReward, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopInferersToReward", wireType)
			}
		case 22:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxTopForecastersToReward = append(m.MaxTopForecastersToReward, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxTopForecastersToReward) == 0 {
					m.MaxTopForecastersToReward = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxTopForecastersToReward = append(m.MaxTopForecastersToReward, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopForecastersToReward", wireType)
			}
		case 23:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxTopReputersToReward = append(m.MaxTopReputersToReward, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxTopReputersToReward) == 0 {
					m.MaxTopReputersToReward = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxTopReputersToReward = append(m.MaxTopReputersToReward, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopReputersToReward", wireType)
			}
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTopicFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.Int
			m.CreateTopicFee = append(m.CreateTopicFee, v)
			if err := m.CreateTopicFee[len(m.CreateTopicFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GradientDescentMaxIters = append(m.GradientDescentMaxIters, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.GradientDescentMaxIters) == 0 {
					m.GradientDescentMaxIters = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GradientDescentMaxIters = append(m.GradientDescentMaxIters, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GradientDescentMaxIters", wireType)
			}
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegistrationFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.Int
			m.RegistrationFee = append(m.RegistrationFee, v)
			if err := m.RegistrationFee[len(m.RegistrationFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.DefaultPageLimit = append(m.DefaultPageLimit, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.DefaultPageLimit) == 0 {
					m.DefaultPageLimit = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.DefaultPageLimit = append(m.DefaultPageLimit, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultPageLimit", wireType)
			}
		case 30:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxPageLimit = append(m.MaxPageLimit, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxPageLimit) == 0 {
					m.MaxPageLimit = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxPageLimit = append(m.MaxPageLimit, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPageLimit", wireType)
			}
		case 31:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MinEpochLengthRecordLimit = append(m.MinEpochLengthRecordLimit, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MinEpochLengthRecordLimit) == 0 {
					m.MinEpochLengthRecordLimit = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MinEpochLengthRecordLimit = append(m.MinEpochLengthRecordLimit, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MinEpochLengthRecordLimit", wireType)
			}
		case 32:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.BlocksPerMonth = append(m.BlocksPerMonth, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.BlocksPerMonth) == 0 {
					m.BlocksPerMonth = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.BlocksPerMonth = append(m.BlocksPerMonth, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksPerMonth", wireType)
			}
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardInference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.PRewardInference = append(m.PRewardInference, v)
			if err := m.PRewardInference[len(m.PRewardInference)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardForecast", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.PRewardForecast = append(m.PRewardForecast, v)
			if err := m.PRewardForecast[len(m.PRewardForecast)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardReputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.PRewardReputer = append(m.PRewardReputer, v)
			if err := m.PRewardReputer[len(m.PRewardReputer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRewardInference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.CRewardInference = append(m.CRewardInference, v)
			if err := m.CRewardInference[len(m.CRewardInference)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRewardForecast", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.CRewardForecast = append(m.CRewardForecast, v)
			if err := m.CRewardForecast[len(m.CRewardForecast)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CNorm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.CNorm = append(m.CNorm, v)
			if err := m.CNorm[len(m.CNorm)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpsilonReputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.EpsilonReputer = append(m.EpsilonReputer, v)
			if err := m.EpsilonReputer[len(m.EpsilonReputer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 42:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.HalfMaxProcessStakeRemovalsEndBlock = append(m.HalfMaxProcessStakeRemovalsEndBlock, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.HalfMaxProcessStakeRemovalsEndBlock) == 0 {
					m.HalfMaxProcessStakeRemovalsEndBlock = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.HalfMaxProcessStakeRemovalsEndBlock = append(m.HalfMaxProcessStakeRemovalsEndBlock, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field HalfMaxProcessStakeRemovalsEndBlock", wireType)
			}
		case 43:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataSendingFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v cosmossdk_io_math.Int
			m.DataSendingFee = append(m.DataSendingFee, v)
			if err := m.DataSendingFee[len(m.DataSendingFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 44:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpsilonSafeDiv", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.EpsilonSafeDiv = append(m.EpsilonSafeDiv, v)
			if err := m.EpsilonSafeDiv[len(m.EpsilonSafeDiv)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 45:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxElementsPerForecast = append(m.MaxElementsPerForecast, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxElementsPerForecast) == 0 {
					m.MaxElementsPerForecast = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxElementsPerForecast = append(m.MaxElementsPerForecast, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxElementsPerForecast", wireType)
			}
		case 46:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxActiveTopicsPerBlock = append(m.MaxActiveTopicsPerBlock, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxActiveTopicsPerBlock) == 0 {
					m.MaxActiveTopicsPerBlock = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxActiveTopicsPerBlock = append(m.MaxActiveTopicsPerBlock, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxActiveTopicsPerBlock", wireType)
			}
		case 47:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxStringLength = append(m.MaxStringLength, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxStringLength) == 0 {
					m.MaxStringLength = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxStringLength = append(m.MaxStringLength, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxStringLength", wireType)
			}
		case 48:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialRegretQuantile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.InitialRegretQuantile = append(m.InitialRegretQuantile, v)
			if err := m.InitialRegretQuantile[len(m.InitialRegretQuantile)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 49:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PNormSafeDiv", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.PNormSafeDiv = append(m.PNormSafeDiv, v)
			if err := m.PNormSafeDiv[len(m.PNormSafeDiv)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 50:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalWhitelistEnabled = append(m.GlobalWhitelistEnabled, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.GlobalWhitelistEnabled) == 0 {
					m.GlobalWhitelistEnabled = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalWhitelistEnabled = append(m.GlobalWhitelistEnabled, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalWhitelistEnabled", wireType)
			}
		case 51:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TopicCreatorWhitelistEnabled = append(m.TopicCreatorWhitelistEnabled, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.TopicCreatorWhitelistEnabled) == 0 {
					m.TopicCreatorWhitelistEnabled = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TopicCreatorWhitelistEnabled = append(m.TopicCreatorWhitelistEnabled, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicCreatorWhitelistEnabled", wireType)
			}
		case 52:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MinExperiencedWorkerRegrets = append(m.MinExperiencedWorkerRegrets, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MinExperiencedWorkerRegrets) == 0 {
					m.MinExperiencedWorkerRegrets = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MinExperiencedWorkerRegrets = append(m.MinExperiencedWorkerRegrets, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MinExperiencedWorkerRegrets", wireType)
			}
		case 53:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceOutlierDetectionThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.InferenceOutlierDetectionThreshold = append(m.InferenceOutlierDetectionThreshold, v)
			if err := m.InferenceOutlierDetectionThreshold[len(m.InferenceOutlierDetectionThreshold)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 54:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceOutlierDetectionAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.InferenceOutlierDetectionAlpha = append(m.InferenceOutlierDetectionAlpha, v)
			if err := m.InferenceOutlierDetectionAlpha[len(m.InferenceOutlierDetectionAlpha)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 55:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LambdaInitialScore", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.LambdaInitialScore = append(m.LambdaInitialScore, v)
			if err := m.LambdaInitialScore[len(m.LambdaInitialScore)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 56:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalWorkerWhitelistEnabled = append(m.GlobalWorkerWhitelistEnabled, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.GlobalWorkerWhitelistEnabled) == 0 {
					m.GlobalWorkerWhitelistEnabled = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalWorkerWhitelistEnabled = append(m.GlobalWorkerWhitelistEnabled, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalWorkerWhitelistEnabled", wireType)
			}
		case 57:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalReputerWhitelistEnabled = append(m.GlobalReputerWhitelistEnabled, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.GlobalReputerWhitelistEnabled) == 0 {
					m.GlobalReputerWhitelistEnabled = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalReputerWhitelistEnabled = append(m.GlobalReputerWhitelistEnabled, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalReputerWhitelistEnabled", wireType)
			}
		case 58:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalAdminWhitelistAppended = append(m.GlobalAdminWhitelistAppended, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.GlobalAdminWhitelistAppended) == 0 {
					m.GlobalAdminWhitelistAppended = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalAdminWhitelistAppended = append(m.GlobalAdminWhitelistAppended, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalAdminWhitelistAppended", wireType)
			}
		case 59:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MaxWhitelistInputArrayLength = append(m.MaxWhitelistInputArrayLength, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MaxWhitelistInputArrayLength) == 0 {
					m.MaxWhitelistInputArrayLength = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MaxWhitelistInputArrayLength = append(m.MaxWhitelistInputArrayLength, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxWhitelistInputArrayLength", wireType)
			}
		case 60:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinWeightThresholdForStdnorm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.MinWeightThresholdForStdnorm = append(m.MinWeightThresholdForStdnorm, v)
			if err := m.MinWeightThresholdForStdnorm[len(m.MinWeightThresholdForStdnorm)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateParamsRequest) 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 ErrIntOverflowTx
			}
			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: UpdateParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Params == nil {
				m.Params = &OptionalParams{}
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateParamsResponse) 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 ErrIntOverflowTx
			}
			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: UpdateParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateNewTopicRequest) 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 ErrIntOverflowTx
			}
			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: CreateNewTopicRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateNewTopicRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LossMethod", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LossMethod = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochLength", wireType)
			}
			m.EpochLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochLength |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroundTruthLag", wireType)
			}
			m.GroundTruthLag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroundTruthLag |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PNorm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PNorm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlphaRegret", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AlphaRegret.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowNegative", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowNegative = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epsilon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Epsilon.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkerSubmissionWindow", wireType)
			}
			m.WorkerSubmissionWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkerSubmissionWindow |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeritSortitionAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MeritSortitionAlpha.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveInfererQuantile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ActiveInfererQuantile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveForecasterQuantile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ActiveForecasterQuantile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveReputerQuantile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ActiveReputerQuantile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableWorkerWhitelist", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableWorkerWhitelist = bool(v != 0)
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableReputerWhitelist", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableReputerWhitelist = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateNewTopicResponse) 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 ErrIntOverflowTx
			}
			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: CreateNewTopicResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateNewTopicResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InsertReputerPayloadRequest) 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 ErrIntOverflowTx
			}
			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: InsertReputerPayloadRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InsertReputerPayloadRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerValueBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReputerValueBundle == nil {
				m.ReputerValueBundle = &InputReputerValueBundle{}
			}
			if err := m.ReputerValueBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InsertReputerPayloadResponse) 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 ErrIntOverflowTx
			}
			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: InsertReputerPayloadResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InsertReputerPayloadResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InsertWorkerPayloadRequest) 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 ErrIntOverflowTx
			}
			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: InsertWorkerPayloadRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InsertWorkerPayloadRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkerDataBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WorkerDataBundle == nil {
				m.WorkerDataBundle = &InputWorkerDataBundle{}
			}
			if err := m.WorkerDataBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InsertWorkerPayloadResponse) 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 ErrIntOverflowTx
			}
			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: InsertWorkerPayloadResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InsertWorkerPayloadResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterRequest) 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 ErrIntOverflowTx
			}
			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: RegisterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsReputer", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsReputer = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterResponse) 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 ErrIntOverflowTx
			}
			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: RegisterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Success = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveRegistrationRequest) 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 ErrIntOverflowTx
			}
			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: RemoveRegistrationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveRegistrationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsReputer", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsReputer = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveRegistrationResponse) 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 ErrIntOverflowTx
			}
			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: RemoveRegistrationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveRegistrationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Success = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddStakeRequest) 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 ErrIntOverflowTx
			}
			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: AddStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddStakeResponse) 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 ErrIntOverflowTx
			}
			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: AddStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveStakeRequest) 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 ErrIntOverflowTx
			}
			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: RemoveStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveStakeResponse) 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 ErrIntOverflowTx
			}
			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: RemoveStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CancelRemoveStakeRequest) 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 ErrIntOverflowTx
			}
			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: CancelRemoveStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelRemoveStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CancelRemoveStakeResponse) 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 ErrIntOverflowTx
			}
			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: CancelRemoveStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelRemoveStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateStakeRequest) 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 ErrIntOverflowTx
			}
			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: DelegateStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateStakeResponse) 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 ErrIntOverflowTx
			}
			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: DelegateStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveDelegateStakeRequest) 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 ErrIntOverflowTx
			}
			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: RemoveDelegateStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveDelegateStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveDelegateStakeResponse) 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 ErrIntOverflowTx
			}
			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: RemoveDelegateStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveDelegateStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CancelRemoveDelegateStakeRequest) 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 ErrIntOverflowTx
			}
			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: CancelRemoveDelegateStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelRemoveDelegateStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CancelRemoveDelegateStakeResponse) 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 ErrIntOverflowTx
			}
			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: CancelRemoveDelegateStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelRemoveDelegateStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RewardDelegateStakeRequest) 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 ErrIntOverflowTx
			}
			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: RewardDelegateStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RewardDelegateStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RewardDelegateStakeResponse) 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 ErrIntOverflowTx
			}
			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: RewardDelegateStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RewardDelegateStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FundTopicRequest) 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 ErrIntOverflowTx
			}
			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: FundTopicRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FundTopicRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FundTopicResponse) 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 ErrIntOverflowTx
			}
			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: FundTopicResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FundTopicResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToWhitelistAdminRequest) 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 ErrIntOverflowTx
			}
			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: AddToWhitelistAdminRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToWhitelistAdminRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToWhitelistAdminResponse) 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 ErrIntOverflowTx
			}
			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: AddToWhitelistAdminResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToWhitelistAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromWhitelistAdminRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromWhitelistAdminRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromWhitelistAdminRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromWhitelistAdminResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromWhitelistAdminResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromWhitelistAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnableTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: EnableTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnableTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnableTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: EnableTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnableTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisableTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: DisableTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisableTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisableTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: DisableTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisableTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnableTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: EnableTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnableTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnableTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: EnableTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnableTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisableTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: DisableTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisableTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisableTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: DisableTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisableTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToGlobalWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToGlobalWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicCreatorWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToTopicCreatorWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicCreatorWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicCreatorWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToTopicCreatorWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicCreatorWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToGlobalWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToGlobalWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToGlobalReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToGlobalReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalAdminWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToGlobalAdminWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalAdminWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToGlobalAdminWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToGlobalAdminWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToGlobalAdminWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalAdminWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalAdminWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalAdminWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromGlobalAdminWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromGlobalAdminWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromGlobalAdminWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToGlobalWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkAddToGlobalWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToGlobalWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToGlobalWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkAddToGlobalWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToGlobalWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromGlobalWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromGlobalWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromGlobalWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromGlobalWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromGlobalWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromGlobalWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToGlobalReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkAddToGlobalReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToGlobalReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToGlobalReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkAddToGlobalReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToGlobalReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromGlobalReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromGlobalReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromGlobalReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromGlobalReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromGlobalReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromGlobalReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkAddToTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkAddToTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkAddToTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkAddToTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkAddToTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkAddToTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BulkRemoveFromTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: BulkRemoveFromTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BulkRemoveFromTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicCreatorWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicCreatorWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicCreatorWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicCreatorWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicCreatorWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicCreatorWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicWorkerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicWorkerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicWorkerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicWorkerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicWorkerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicWorkerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: AddToTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddToTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: AddToTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddToTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicReputerWhitelistRequest) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicReputerWhitelistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicReputerWhitelistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveFromTopicReputerWhitelistResponse) 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 ErrIntOverflowTx
			}
			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: RemoveFromTopicReputerWhitelistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFromTopicReputerWhitelistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
