tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: juno/feepay/v1/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "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"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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

// The message to register a fee pay contract.
type MsgRegisterFeePayContract struct {
	// The wallet address of the sender.
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	// The fee pay contract to register.
	FeePayContract *FeePayContract `protobuf:"bytes,2,opt,name=fee_pay_contract,json=feePayContract,proto3" json:"fee_pay_contract,omitempty"`
}

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

var xxx_messageInfo_MsgRegisterFeePayContract proto.InternalMessageInfo

func (m *MsgRegisterFeePayContract) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

func (m *MsgRegisterFeePayContract) GetFeePayContract() *FeePayContract {
	if m != nil {
		return m.FeePayContract
	}
	return nil
}

// The response message for registering a fee pay contract.
type MsgRegisterFeePayContractResponse struct {
}

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

var xxx_messageInfo_MsgRegisterFeePayContractResponse proto.InternalMessageInfo

// The message to unregister a fee pay contract.
type MsgUnregisterFeePayContract struct {
	// The wallet address of the sender.
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	// The fee pay contract address.
	ContractAddress string `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
}

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

var xxx_messageInfo_MsgUnregisterFeePayContract proto.InternalMessageInfo

func (m *MsgUnregisterFeePayContract) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

func (m *MsgUnregisterFeePayContract) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// The response message for unregistering a fee pay contract.
type MsgUnregisterFeePayContractResponse struct {
}

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

var xxx_messageInfo_MsgUnregisterFeePayContractResponse proto.InternalMessageInfo

// The message to fund a fee pay contract
type MsgFundFeePayContract struct {
	// The wallet address of the sender.
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	// The fee pay contract to fund.
	ContractAddress string `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	// The coins to fund the contract with.
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
}

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

var xxx_messageInfo_MsgFundFeePayContract proto.InternalMessageInfo

func (m *MsgFundFeePayContract) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

func (m *MsgFundFeePayContract) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

func (m *MsgFundFeePayContract) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

// The response message for funding a fee pay contract.
type MsgFundFeePayContractResponse struct {
}

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

var xxx_messageInfo_MsgFundFeePayContractResponse proto.InternalMessageInfo

// The message to update a fee pay contract wallet limit.
type MsgUpdateFeePayContractWalletLimit struct {
	// The wallet address of the sender.
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	// The fee pay contract to fund.
	ContractAddress string `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	// The new wallet limit.
	WalletLimit uint64 `protobuf:"varint,3,opt,name=wallet_limit,json=walletLimit,proto3" json:"wallet_limit,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateFeePayContractWalletLimit proto.InternalMessageInfo

func (m *MsgUpdateFeePayContractWalletLimit) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

func (m *MsgUpdateFeePayContractWalletLimit) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

func (m *MsgUpdateFeePayContractWalletLimit) GetWalletLimit() uint64 {
	if m != nil {
		return m.WalletLimit
	}
	return 0
}

// The response message for updating a fee pay contract wallet limit.
type MsgUpdateFeePayContractWalletLimitResponse struct {
}

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

var xxx_messageInfo_MsgUpdateFeePayContractWalletLimitResponse proto.InternalMessageInfo

// MsgUpdateParams is the Msg/UpdateParams request type.
//
// Since: cosmos-sdk 0.47
type MsgUpdateParams struct {
	// authority is the address that controls the module (defaults to x/gov unless overwritten).
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// params defines the x/feepay parameters to update.
	//
	// NOTE: All parameters must be supplied.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo

func (m *MsgUpdateParams) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

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

// MsgUpdateParamsResponse defines the response structure for executing a
// MsgUpdateParams message.
//
// Since: cosmos-sdk 0.47
type MsgUpdateParamsResponse struct {
}

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

var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgRegisterFeePayContract)(nil), "juno.feepay.v1.MsgRegisterFeePayContract")
	proto.RegisterType((*MsgRegisterFeePayContractResponse)(nil), "juno.feepay.v1.MsgRegisterFeePayContractResponse")
	proto.RegisterType((*MsgUnregisterFeePayContract)(nil), "juno.feepay.v1.MsgUnregisterFeePayContract")
	proto.RegisterType((*MsgUnregisterFeePayContractResponse)(nil), "juno.feepay.v1.MsgUnregisterFeePayContractResponse")
	proto.RegisterType((*MsgFundFeePayContract)(nil), "juno.feepay.v1.MsgFundFeePayContract")
	proto.RegisterType((*MsgFundFeePayContractResponse)(nil), "juno.feepay.v1.MsgFundFeePayContractResponse")
	proto.RegisterType((*MsgUpdateFeePayContractWalletLimit)(nil), "juno.feepay.v1.MsgUpdateFeePayContractWalletLimit")
	proto.RegisterType((*MsgUpdateFeePayContractWalletLimitResponse)(nil), "juno.feepay.v1.MsgUpdateFeePayContractWalletLimitResponse")
	proto.RegisterType((*MsgUpdateParams)(nil), "juno.feepay.v1.MsgUpdateParams")
	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "juno.feepay.v1.MsgUpdateParamsResponse")
}

func init() { proto.RegisterFile("juno/feepay/v1/tx.proto", fileDescriptor_d739bd30c8846fd5) }

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

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// RegisterFeeShare registers a new contract for receiving transaction fees
	RegisterFeePayContract(ctx context.Context, in *MsgRegisterFeePayContract, opts ...grpc.CallOption) (*MsgRegisterFeePayContractResponse, error)
	// UnregisterFeeShare unregisters a contract for receiving transaction fees
	UnregisterFeePayContract(ctx context.Context, in *MsgUnregisterFeePayContract, opts ...grpc.CallOption) (*MsgUnregisterFeePayContractResponse, error)
	// Fund a fee pay contract
	FundFeePayContract(ctx context.Context, in *MsgFundFeePayContract, opts ...grpc.CallOption) (*MsgFundFeePayContractResponse, error)
	// Update a fee pay contract wallet limit
	UpdateFeePayContractWalletLimit(ctx context.Context, in *MsgUpdateFeePayContractWalletLimit, opts ...grpc.CallOption) (*MsgUpdateFeePayContractWalletLimitResponse, error)
	// Update the params of the module through gov v1 type.
	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) RegisterFeePayContract(ctx context.Context, in *MsgRegisterFeePayContract, opts ...grpc.CallOption) (*MsgRegisterFeePayContractResponse, error) {
	out := new(MsgRegisterFeePayContractResponse)
	err := c.cc.Invoke(ctx, "/juno.feepay.v1.Msg/RegisterFeePayContract", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UnregisterFeePayContract(ctx context.Context, in *MsgUnregisterFeePayContract, opts ...grpc.CallOption) (*MsgUnregisterFeePayContractResponse, error) {
	out := new(MsgUnregisterFeePayContractResponse)
	err := c.cc.Invoke(ctx, "/juno.feepay.v1.Msg/UnregisterFeePayContract", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) FundFeePayContract(ctx context.Context, in *MsgFundFeePayContract, opts ...grpc.CallOption) (*MsgFundFeePayContractResponse, error) {
	out := new(MsgFundFeePayContractResponse)
	err := c.cc.Invoke(ctx, "/juno.feepay.v1.Msg/FundFeePayContract", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateFeePayContractWalletLimit(ctx context.Context, in *MsgUpdateFeePayContractWalletLimit, opts ...grpc.CallOption) (*MsgUpdateFeePayContractWalletLimitResponse, error) {
	out := new(MsgUpdateFeePayContractWalletLimitResponse)
	err := c.cc.Invoke(ctx, "/juno.feepay.v1.Msg/UpdateFeePayContractWalletLimit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
	out := new(MsgUpdateParamsResponse)
	err := c.cc.Invoke(ctx, "/juno.feepay.v1.Msg/UpdateParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// RegisterFeeShare registers a new contract for receiving transaction fees
	RegisterFeePayContract(context.Context, *MsgRegisterFeePayContract) (*MsgRegisterFeePayContractResponse, error)
	// UnregisterFeeShare unregisters a contract for receiving transaction fees
	UnregisterFeePayContract(context.Context, *MsgUnregisterFeePayContract) (*MsgUnregisterFeePayContractResponse, error)
	// Fund a fee pay contract
	FundFeePayContract(context.Context, *MsgFundFeePayContract) (*MsgFundFeePayContractResponse, error)
	// Update a fee pay contract wallet limit
	UpdateFeePayContractWalletLimit(context.Context, *MsgUpdateFeePayContractWalletLimit) (*MsgUpdateFeePayContractWalletLimitResponse, error)
	// Update the params of the module through gov v1 type.
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
}

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

func (*UnimplementedMsgServer) RegisterFeePayContract(ctx context.Context, req *MsgRegisterFeePayContract) (*MsgRegisterFeePayContractResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterFeePayContract not implemented")
}
func (*UnimplementedMsgServer) UnregisterFeePayContract(ctx context.Context, req *MsgUnregisterFeePayContract) (*MsgUnregisterFeePayContractResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnregisterFeePayContract not implemented")
}
func (*UnimplementedMsgServer) FundFeePayContract(ctx context.Context, req *MsgFundFeePayContract) (*MsgFundFeePayContractResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FundFeePayContract not implemented")
}
func (*UnimplementedMsgServer) UpdateFeePayContractWalletLimit(ctx context.Context, req *MsgUpdateFeePayContractWalletLimit) (*MsgUpdateFeePayContractWalletLimitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateFeePayContractWalletLimit not implemented")
}
func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_RegisterFeePayContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRegisterFeePayContract)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RegisterFeePayContract(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/juno.feepay.v1.Msg/RegisterFeePayContract",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RegisterFeePayContract(ctx, req.(*MsgRegisterFeePayContract))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UnregisterFeePayContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnregisterFeePayContract)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UnregisterFeePayContract(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/juno.feepay.v1.Msg/UnregisterFeePayContract",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UnregisterFeePayContract(ctx, req.(*MsgUnregisterFeePayContract))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_FundFeePayContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgFundFeePayContract)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).FundFeePayContract(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/juno.feepay.v1.Msg/FundFeePayContract",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).FundFeePayContract(ctx, req.(*MsgFundFeePayContract))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateFeePayContractWalletLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateFeePayContractWalletLimit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateFeePayContractWalletLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/juno.feepay.v1.Msg/UpdateFeePayContractWalletLimit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateFeePayContractWalletLimit(ctx, req.(*MsgUpdateFeePayContractWalletLimit))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/juno.feepay.v1.Msg/UpdateParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "juno.feepay.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterFeePayContract",
			Handler:    _Msg_RegisterFeePayContract_Handler,
		},
		{
			MethodName: "UnregisterFeePayContract",
			Handler:    _Msg_UnregisterFeePayContract_Handler,
		},
		{
			MethodName: "FundFeePayContract",
			Handler:    _Msg_FundFeePayContract_Handler,
		},
		{
			MethodName: "UpdateFeePayContractWalletLimit",
			Handler:    _Msg_UpdateFeePayContractWalletLimit_Handler,
		},
		{
			MethodName: "UpdateParams",
			Handler:    _Msg_UpdateParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "juno/feepay/v1/tx.proto",
}

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

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

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

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

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

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

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

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

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

func (m *MsgFundFeePayContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ContractAddress) > 0 {
		i -= len(m.ContractAddress)
		copy(dAtA[i:], m.ContractAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SenderAddress) > 0 {
		i -= len(m.SenderAddress)
		copy(dAtA[i:], m.SenderAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SenderAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		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.Authority) > 0 {
		i -= len(m.Authority)
		copy(dAtA[i:], m.Authority)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgUpdateParamsResponse) 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 *MsgRegisterFeePayContract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.FeePayContract != nil {
		l = m.FeePayContract.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

func (m *MsgFundFeePayContract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

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

func (m *MsgUpdateFeePayContractWalletLimit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.WalletLimit != 0 {
		n += 1 + sovTx(uint64(m.WalletLimit))
	}
	return n
}

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

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

func (m *MsgUpdateParamsResponse) 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 *MsgRegisterFeePayContract) 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: MsgRegisterFeePayContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterFeePayContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeePayContract", 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.FeePayContract == nil {
				m.FeePayContract = &FeePayContract{}
			}
			if err := m.FeePayContract.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 *MsgRegisterFeePayContractResponse) 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: MsgRegisterFeePayContractResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterFeePayContractResponse: 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 *MsgUnregisterFeePayContract) 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: MsgUnregisterFeePayContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnregisterFeePayContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", 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.ContractAddress = 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 *MsgUnregisterFeePayContractResponse) 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: MsgUnregisterFeePayContractResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnregisterFeePayContractResponse: 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 *MsgFundFeePayContract) 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: MsgFundFeePayContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgFundFeePayContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", 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.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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
			}
			m.Amount = append(m.Amount, types.Coin{})
			if err := m.Amount[len(m.Amount)-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 *MsgFundFeePayContractResponse) 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: MsgFundFeePayContractResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgFundFeePayContractResponse: 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 *MsgUpdateFeePayContractWalletLimit) 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: MsgUpdateFeePayContractWalletLimit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateFeePayContractWalletLimit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", 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.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WalletLimit", wireType)
			}
			m.WalletLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WalletLimit |= 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 *MsgUpdateFeePayContractWalletLimitResponse) 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: MsgUpdateFeePayContractWalletLimitResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateFeePayContractWalletLimitResponse: 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 *MsgUpdateParams) 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: MsgUpdateParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = 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 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 *MsgUpdateParamsResponse) 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: MsgUpdateParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParamsResponse: 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")
)