genesis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: records/genesis.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	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

type DepositRecord_Status int32

const (
	// pending transfer to delegate account
	DepositRecord_TRANSFER DepositRecord_Status = 0
	// pending staking on delegate account
	DepositRecord_STAKE DepositRecord_Status = 1
)

var DepositRecord_Status_name = map[int32]string{
	0: "TRANSFER",
	1: "STAKE",
}

var DepositRecord_Status_value = map[string]int32{
	"TRANSFER": 0,
	"STAKE":    1,
}

func (x DepositRecord_Status) String() string {
	return proto.EnumName(DepositRecord_Status_name, int32(x))
}

func (DepositRecord_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_03dd178cbf8084c6, []int{4, 0}
}

type DepositRecord_Source int32

const (
	DepositRecord_STRIDE         DepositRecord_Source = 0
	DepositRecord_WITHDRAWAL_ICA DepositRecord_Source = 1
)

var DepositRecord_Source_name = map[int32]string{
	0: "STRIDE",
	1: "WITHDRAWAL_ICA",
}

var DepositRecord_Source_value = map[string]int32{
	"STRIDE":         0,
	"WITHDRAWAL_ICA": 1,
}

func (x DepositRecord_Source) String() string {
	return proto.EnumName(DepositRecord_Source_name, int32(x))
}

func (DepositRecord_Source) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_03dd178cbf8084c6, []int{4, 1}
}

type HostZoneUnbonding_Status int32

const (
	// tokens bonded on delegate account
	HostZoneUnbonding_BONDED HostZoneUnbonding_Status = 0
	// unbonding completed on delegate account
	HostZoneUnbonding_UNBONDED HostZoneUnbonding_Status = 1
	// transfer success
	HostZoneUnbonding_TRANSFERRED HostZoneUnbonding_Status = 2
)

var HostZoneUnbonding_Status_name = map[int32]string{
	0: "BONDED",
	1: "UNBONDED",
	2: "TRANSFERRED",
}

var HostZoneUnbonding_Status_value = map[string]int32{
	"BONDED":      0,
	"UNBONDED":    1,
	"TRANSFERRED": 2,
}

func (x HostZoneUnbonding_Status) String() string {
	return proto.EnumName(HostZoneUnbonding_Status_name, int32(x))
}

func (HostZoneUnbonding_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_03dd178cbf8084c6, []int{5, 0}
}

type UserRedemptionRecord struct {
	Id             string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Sender         string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	Receiver       string `protobuf:"bytes,3,opt,name=receiver,proto3" json:"receiver,omitempty"`
	Amount         uint64 `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	Denom          string `protobuf:"bytes,5,opt,name=denom,proto3" json:"denom,omitempty"`
	HostZoneId     string `protobuf:"bytes,6,opt,name=hostZoneId,proto3" json:"hostZoneId,omitempty"`
	EpochNumber    uint64 `protobuf:"varint,7,opt,name=epochNumber,proto3" json:"epochNumber,omitempty"`
	ClaimIsPending bool   `protobuf:"varint,8,opt,name=claimIsPending,proto3" json:"claimIsPending,omitempty"`
}

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

var xxx_messageInfo_UserRedemptionRecord proto.InternalMessageInfo

func (m *UserRedemptionRecord) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *UserRedemptionRecord) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

func (m *UserRedemptionRecord) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *UserRedemptionRecord) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

func (m *UserRedemptionRecord) GetHostZoneId() string {
	if m != nil {
		return m.HostZoneId
	}
	return ""
}

func (m *UserRedemptionRecord) GetEpochNumber() uint64 {
	if m != nil {
		return m.EpochNumber
	}
	return 0
}

func (m *UserRedemptionRecord) GetClaimIsPending() bool {
	if m != nil {
		return m.ClaimIsPending
	}
	return false
}

// Params defines the parameters for the module.
type Params struct {
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

type RecordsPacketData struct {
	// Types that are valid to be assigned to Packet:
	//	*RecordsPacketData_NoData
	Packet isRecordsPacketData_Packet `protobuf_oneof:"packet"`
}

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

var xxx_messageInfo_RecordsPacketData proto.InternalMessageInfo

type isRecordsPacketData_Packet interface {
	isRecordsPacketData_Packet()
	MarshalTo([]byte) (int, error)
	Size() int
}

type RecordsPacketData_NoData struct {
	NoData *NoData `protobuf:"bytes,1,opt,name=noData,proto3,oneof" json:"noData,omitempty"`
}

func (*RecordsPacketData_NoData) isRecordsPacketData_Packet() {}

func (m *RecordsPacketData) GetPacket() isRecordsPacketData_Packet {
	if m != nil {
		return m.Packet
	}
	return nil
}

func (m *RecordsPacketData) GetNoData() *NoData {
	if x, ok := m.GetPacket().(*RecordsPacketData_NoData); ok {
		return x.NoData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RecordsPacketData) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RecordsPacketData_NoData)(nil),
	}
}

type NoData struct {
}

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

var xxx_messageInfo_NoData proto.InternalMessageInfo

type DepositRecord struct {
	Id                 uint64               `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Amount             int64                `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Denom              string               `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
	HostZoneId         string               `protobuf:"bytes,4,opt,name=hostZoneId,proto3" json:"hostZoneId,omitempty"`
	Status             DepositRecord_Status `protobuf:"varint,6,opt,name=status,proto3,enum=Stridelabs.stride.records.DepositRecord_Status" json:"status,omitempty"`
	DepositEpochNumber uint64               `protobuf:"varint,7,opt,name=depositEpochNumber,proto3" json:"depositEpochNumber,omitempty"`
	Source             DepositRecord_Source `protobuf:"varint,8,opt,name=source,proto3,enum=Stridelabs.stride.records.DepositRecord_Source" json:"source,omitempty"`
}

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

var xxx_messageInfo_DepositRecord proto.InternalMessageInfo

func (m *DepositRecord) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *DepositRecord) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *DepositRecord) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

func (m *DepositRecord) GetHostZoneId() string {
	if m != nil {
		return m.HostZoneId
	}
	return ""
}

func (m *DepositRecord) GetStatus() DepositRecord_Status {
	if m != nil {
		return m.Status
	}
	return DepositRecord_TRANSFER
}

func (m *DepositRecord) GetDepositEpochNumber() uint64 {
	if m != nil {
		return m.DepositEpochNumber
	}
	return 0
}

func (m *DepositRecord) GetSource() DepositRecord_Source {
	if m != nil {
		return m.Source
	}
	return DepositRecord_STRIDE
}

type HostZoneUnbonding struct {
	StTokenAmount         uint64                   `protobuf:"varint,1,opt,name=stTokenAmount,proto3" json:"stTokenAmount,omitempty"`
	NativeTokenAmount     uint64                   `protobuf:"varint,2,opt,name=nativeTokenAmount,proto3" json:"nativeTokenAmount,omitempty"`
	Denom                 string                   `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
	HostZoneId            string                   `protobuf:"bytes,4,opt,name=hostZoneId,proto3" json:"hostZoneId,omitempty"`
	UnbondingTime         uint64                   `protobuf:"varint,5,opt,name=unbondingTime,proto3" json:"unbondingTime,omitempty"`
	Status                HostZoneUnbonding_Status `protobuf:"varint,6,opt,name=status,proto3,enum=Stridelabs.stride.records.HostZoneUnbonding_Status" json:"status,omitempty"`
	UserRedemptionRecords []string                 `protobuf:"bytes,7,rep,name=userRedemptionRecords,proto3" json:"userRedemptionRecords,omitempty"`
}

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

var xxx_messageInfo_HostZoneUnbonding proto.InternalMessageInfo

func (m *HostZoneUnbonding) GetStTokenAmount() uint64 {
	if m != nil {
		return m.StTokenAmount
	}
	return 0
}

func (m *HostZoneUnbonding) GetNativeTokenAmount() uint64 {
	if m != nil {
		return m.NativeTokenAmount
	}
	return 0
}

func (m *HostZoneUnbonding) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

func (m *HostZoneUnbonding) GetHostZoneId() string {
	if m != nil {
		return m.HostZoneId
	}
	return ""
}

func (m *HostZoneUnbonding) GetUnbondingTime() uint64 {
	if m != nil {
		return m.UnbondingTime
	}
	return 0
}

func (m *HostZoneUnbonding) GetStatus() HostZoneUnbonding_Status {
	if m != nil {
		return m.Status
	}
	return HostZoneUnbonding_BONDED
}

func (m *HostZoneUnbonding) GetUserRedemptionRecords() []string {
	if m != nil {
		return m.UserRedemptionRecords
	}
	return nil
}

type EpochUnbondingRecord struct {
	EpochNumber        uint64               `protobuf:"varint,1,opt,name=epochNumber,proto3" json:"epochNumber,omitempty"`
	HostZoneUnbondings []*HostZoneUnbonding `protobuf:"bytes,3,rep,name=hostZoneUnbondings,proto3" json:"hostZoneUnbondings,omitempty"`
}

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

var xxx_messageInfo_EpochUnbondingRecord proto.InternalMessageInfo

func (m *EpochUnbondingRecord) GetEpochNumber() uint64 {
	if m != nil {
		return m.EpochNumber
	}
	return 0
}

func (m *EpochUnbondingRecord) GetHostZoneUnbondings() []*HostZoneUnbonding {
	if m != nil {
		return m.HostZoneUnbondings
	}
	return nil
}

// GenesisState defines the recordπs module's genesis state.
// next id: 9
type GenesisState struct {
	Params                    Params                 `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	PortId                    string                 `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	UserRedemptionRecordList  []UserRedemptionRecord `protobuf:"bytes,3,rep,name=userRedemptionRecordList,proto3" json:"userRedemptionRecordList"`
	UserRedemptionRecordCount uint64                 `protobuf:"varint,4,opt,name=userRedemptionRecordCount,proto3" json:"userRedemptionRecordCount,omitempty"`
	EpochUnbondingRecordList  []EpochUnbondingRecord `protobuf:"bytes,5,rep,name=epochUnbondingRecordList,proto3" json:"epochUnbondingRecordList"`
	DepositRecordList         []DepositRecord        `protobuf:"bytes,7,rep,name=depositRecordList,proto3" json:"depositRecordList"`
	DepositRecordCount        uint64                 `protobuf:"varint,8,opt,name=depositRecordCount,proto3" json:"depositRecordCount,omitempty"`
}

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

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

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

func (m *GenesisState) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *GenesisState) GetUserRedemptionRecordList() []UserRedemptionRecord {
	if m != nil {
		return m.UserRedemptionRecordList
	}
	return nil
}

func (m *GenesisState) GetUserRedemptionRecordCount() uint64 {
	if m != nil {
		return m.UserRedemptionRecordCount
	}
	return 0
}

func (m *GenesisState) GetEpochUnbondingRecordList() []EpochUnbondingRecord {
	if m != nil {
		return m.EpochUnbondingRecordList
	}
	return nil
}

func (m *GenesisState) GetDepositRecordList() []DepositRecord {
	if m != nil {
		return m.DepositRecordList
	}
	return nil
}

func (m *GenesisState) GetDepositRecordCount() uint64 {
	if m != nil {
		return m.DepositRecordCount
	}
	return 0
}

func init() {
	proto.RegisterEnum("Stridelabs.stride.records.DepositRecord_Status", DepositRecord_Status_name, DepositRecord_Status_value)
	proto.RegisterEnum("Stridelabs.stride.records.DepositRecord_Source", DepositRecord_Source_name, DepositRecord_Source_value)
	proto.RegisterEnum("Stridelabs.stride.records.HostZoneUnbonding_Status", HostZoneUnbonding_Status_name, HostZoneUnbonding_Status_value)
	proto.RegisterType((*UserRedemptionRecord)(nil), "Stridelabs.stride.records.UserRedemptionRecord")
	proto.RegisterType((*Params)(nil), "Stridelabs.stride.records.Params")
	proto.RegisterType((*RecordsPacketData)(nil), "Stridelabs.stride.records.RecordsPacketData")
	proto.RegisterType((*NoData)(nil), "Stridelabs.stride.records.NoData")
	proto.RegisterType((*DepositRecord)(nil), "Stridelabs.stride.records.DepositRecord")
	proto.RegisterType((*HostZoneUnbonding)(nil), "Stridelabs.stride.records.HostZoneUnbonding")
	proto.RegisterType((*EpochUnbondingRecord)(nil), "Stridelabs.stride.records.EpochUnbondingRecord")
	proto.RegisterType((*GenesisState)(nil), "Stridelabs.stride.records.GenesisState")
}

func init() { proto.RegisterFile("records/genesis.proto", fileDescriptor_03dd178cbf8084c6) }

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

type msgClient struct {
	cc grpc1.ClientConn
}

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

// MsgServer is the server API for Msg service.
type MsgServer interface {
}

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

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

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Stridelabs.stride.records.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams:     []grpc.StreamDesc{},
	Metadata:    "records/genesis.proto",
}

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

func (m *UserRedemptionRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClaimIsPending {
		i--
		if m.ClaimIsPending {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.EpochNumber != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x38
	}
	if len(m.HostZoneId) > 0 {
		i -= len(m.HostZoneId)
		copy(dAtA[i:], m.HostZoneId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.HostZoneId)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Amount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *RecordsPacketData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Packet != nil {
		{
			size := m.Packet.Size()
			i -= size
			if _, err := m.Packet.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *RecordsPacketData_NoData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordsPacketData_NoData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NoData != nil {
		{
			size, err := m.NoData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *NoData) 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 *NoData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *DepositRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Source != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Source))
		i--
		dAtA[i] = 0x40
	}
	if m.DepositEpochNumber != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.DepositEpochNumber))
		i--
		dAtA[i] = 0x38
	}
	if m.Status != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x30
	}
	if len(m.HostZoneId) > 0 {
		i -= len(m.HostZoneId)
		copy(dAtA[i:], m.HostZoneId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.HostZoneId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Amount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *HostZoneUnbonding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UserRedemptionRecords) > 0 {
		for iNdEx := len(m.UserRedemptionRecords) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UserRedemptionRecords[iNdEx])
			copy(dAtA[i:], m.UserRedemptionRecords[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.UserRedemptionRecords[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Status != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x30
	}
	if m.UnbondingTime != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.UnbondingTime))
		i--
		dAtA[i] = 0x28
	}
	if len(m.HostZoneId) > 0 {
		i -= len(m.HostZoneId)
		copy(dAtA[i:], m.HostZoneId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.HostZoneId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x1a
	}
	if m.NativeTokenAmount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.NativeTokenAmount))
		i--
		dAtA[i] = 0x10
	}
	if m.StTokenAmount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.StTokenAmount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EpochUnbondingRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HostZoneUnbondings) > 0 {
		for iNdEx := len(m.HostZoneUnbondings) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HostZoneUnbondings[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.EpochNumber != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DepositRecordCount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.DepositRecordCount))
		i--
		dAtA[i] = 0x40
	}
	if len(m.DepositRecordList) > 0 {
		for iNdEx := len(m.DepositRecordList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DepositRecordList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.EpochUnbondingRecordList) > 0 {
		for iNdEx := len(m.EpochUnbondingRecordList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EpochUnbondingRecordList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.UserRedemptionRecordCount != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.UserRedemptionRecordCount))
		i--
		dAtA[i] = 0x20
	}
	if len(m.UserRedemptionRecordList) > 0 {
		for iNdEx := len(m.UserRedemptionRecordList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UserRedemptionRecordList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenesis(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *UserRedemptionRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovGenesis(uint64(m.Amount))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.HostZoneId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.EpochNumber != 0 {
		n += 1 + sovGenesis(uint64(m.EpochNumber))
	}
	if m.ClaimIsPending {
		n += 2
	}
	return n
}

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

func (m *RecordsPacketData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Packet != nil {
		n += m.Packet.Size()
	}
	return n
}

func (m *RecordsPacketData_NoData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoData != nil {
		l = m.NoData.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}
func (m *NoData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DepositRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovGenesis(uint64(m.Id))
	}
	if m.Amount != 0 {
		n += 1 + sovGenesis(uint64(m.Amount))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.HostZoneId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovGenesis(uint64(m.Status))
	}
	if m.DepositEpochNumber != 0 {
		n += 1 + sovGenesis(uint64(m.DepositEpochNumber))
	}
	if m.Source != 0 {
		n += 1 + sovGenesis(uint64(m.Source))
	}
	return n
}

func (m *HostZoneUnbonding) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StTokenAmount != 0 {
		n += 1 + sovGenesis(uint64(m.StTokenAmount))
	}
	if m.NativeTokenAmount != 0 {
		n += 1 + sovGenesis(uint64(m.NativeTokenAmount))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.HostZoneId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.UnbondingTime != 0 {
		n += 1 + sovGenesis(uint64(m.UnbondingTime))
	}
	if m.Status != 0 {
		n += 1 + sovGenesis(uint64(m.Status))
	}
	if len(m.UserRedemptionRecords) > 0 {
		for _, s := range m.UserRedemptionRecords {
			l = len(s)
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *EpochUnbondingRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochNumber != 0 {
		n += 1 + sovGenesis(uint64(m.EpochNumber))
	}
	if len(m.HostZoneUnbondings) > 0 {
		for _, e := range m.HostZoneUnbondings {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.UserRedemptionRecordList) > 0 {
		for _, e := range m.UserRedemptionRecordList {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.UserRedemptionRecordCount != 0 {
		n += 1 + sovGenesis(uint64(m.UserRedemptionRecordCount))
	}
	if len(m.EpochUnbondingRecordList) > 0 {
		for _, e := range m.EpochUnbondingRecordList {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DepositRecordList) > 0 {
		for _, e := range m.DepositRecordList {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.DepositRecordCount != 0 {
		n += 1 + sovGenesis(uint64(m.DepositRecordCount))
	}
	return n
}

func sovGenesis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *UserRedemptionRecord) 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 ErrIntOverflowGenesis
			}
			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: UserRedemptionRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserRedemptionRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
			}
			m.EpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimIsPending", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ClaimIsPending = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecordsPacketData) 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 ErrIntOverflowGenesis
			}
			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: RecordsPacketData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordsPacketData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NoData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Packet = &RecordsPacketData_NoData{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DepositRecord) 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 ErrIntOverflowGenesis
			}
			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: DepositRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DepositRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= DepositRecord_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositEpochNumber", wireType)
			}
			m.DepositEpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DepositEpochNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= DepositRecord_Source(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostZoneUnbonding) 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 ErrIntOverflowGenesis
			}
			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: HostZoneUnbonding: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostZoneUnbonding: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StTokenAmount", wireType)
			}
			m.StTokenAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StTokenAmount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NativeTokenAmount", wireType)
			}
			m.NativeTokenAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NativeTokenAmount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
			}
			m.UnbondingTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondingTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= HostZoneUnbonding_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserRedemptionRecords", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserRedemptionRecords = append(m.UserRedemptionRecords, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EpochUnbondingRecord) 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 ErrIntOverflowGenesis
			}
			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: EpochUnbondingRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EpochUnbondingRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
			}
			m.EpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZoneUnbondings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostZoneUnbondings = append(m.HostZoneUnbondings, &HostZoneUnbonding{})
			if err := m.HostZoneUnbondings[len(m.HostZoneUnbondings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenesisState) 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 ErrIntOverflowGenesis
			}
			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: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserRedemptionRecordList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserRedemptionRecordList = append(m.UserRedemptionRecordList, UserRedemptionRecord{})
			if err := m.UserRedemptionRecordList[len(m.UserRedemptionRecordList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserRedemptionRecordCount", wireType)
			}
			m.UserRedemptionRecordCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserRedemptionRecordCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochUnbondingRecordList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EpochUnbondingRecordList = append(m.EpochUnbondingRecordList, EpochUnbondingRecord{})
			if err := m.EpochUnbondingRecordList[len(m.EpochUnbondingRecordList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositRecordList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DepositRecordList = append(m.DepositRecordList, DepositRecord{})
			if err := m.DepositRecordList[len(m.DepositRecordList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositRecordCount", wireType)
			}
			m.DepositRecordCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DepositRecordCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenesis(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, ErrIntOverflowGenesis
			}
			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, ErrIntOverflowGenesis
				}
				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, ErrIntOverflowGenesis
				}
				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, ErrInvalidLengthGenesis
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenesis
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenesis
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)