gal.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: nova/gal/v1/gal.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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 struct {
	ZoneId    string                  `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
	Depositor string                  `protobuf:"bytes,2,opt,name=depositor,proto3" json:"depositor,omitempty"`
	Records   []*DepositRecordContent `protobuf:"bytes,3,rep,name=records,proto3" json:"records,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_995e5185773ac6e7, []int{0}
}
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) GetZoneId() string {
	if m != nil {
		return m.ZoneId
	}
	return ""
}

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

func (m *DepositRecord) GetRecords() []*DepositRecordContent {
	if m != nil {
		return m.Records
	}
	return nil
}

type DepositRecordContent struct {
	Claimer string      `protobuf:"bytes,1,opt,name=claimer,proto3" json:"claimer,omitempty"`
	Amount  *types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	State   int64       `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
}

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

var xxx_messageInfo_DepositRecordContent proto.InternalMessageInfo

func (m *DepositRecordContent) GetClaimer() string {
	if m != nil {
		return m.Claimer
	}
	return ""
}

func (m *DepositRecordContent) GetAmount() *types.Coin {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *DepositRecordContent) GetState() int64 {
	if m != nil {
		return m.State
	}
	return 0
}

type DelegateRecord struct {
	ZoneId  string                            `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
	Claimer string                            `protobuf:"bytes,2,opt,name=claimer,proto3" json:"claimer,omitempty"`
	Records map[uint64]*DelegateRecordContent `protobuf:"bytes,3,rep,name=records,proto3" json:"records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *DelegateRecord) Reset()         { *m = DelegateRecord{} }
func (m *DelegateRecord) String() string { return proto.CompactTextString(m) }
func (*DelegateRecord) ProtoMessage()    {}
func (*DelegateRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_995e5185773ac6e7, []int{2}
}
func (m *DelegateRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegateRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DelegateRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegateRecord.Merge(m, src)
}
func (m *DelegateRecord) XXX_Size() int {
	return m.Size()
}
func (m *DelegateRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegateRecord.DiscardUnknown(m)
}

var xxx_messageInfo_DelegateRecord proto.InternalMessageInfo

func (m *DelegateRecord) GetZoneId() string {
	if m != nil {
		return m.ZoneId
	}
	return ""
}

func (m *DelegateRecord) GetClaimer() string {
	if m != nil {
		return m.Claimer
	}
	return ""
}

func (m *DelegateRecord) GetRecords() map[uint64]*DelegateRecordContent {
	if m != nil {
		return m.Records
	}
	return nil
}

type DelegateRecordContent struct {
	Amount        *types.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
	State         int64       `protobuf:"varint,2,opt,name=state,proto3" json:"state,omitempty"`
	OracleVersion uint64      `protobuf:"varint,3,opt,name=oracle_version,json=oracleVersion,proto3" json:"oracle_version,omitempty"`
}

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

var xxx_messageInfo_DelegateRecordContent proto.InternalMessageInfo

func (m *DelegateRecordContent) GetAmount() *types.Coin {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *DelegateRecordContent) GetState() int64 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *DelegateRecordContent) GetOracleVersion() uint64 {
	if m != nil {
		return m.OracleVersion
	}
	return 0
}

type UndelegateRecord struct {
	ZoneId    string                     `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
	Delegator string                     `protobuf:"bytes,2,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Records   []*UndelegateRecordContent `protobuf:"bytes,3,rep,name=records,proto3" json:"records,omitempty"`
}

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

var xxx_messageInfo_UndelegateRecord proto.InternalMessageInfo

func (m *UndelegateRecord) GetZoneId() string {
	if m != nil {
		return m.ZoneId
	}
	return ""
}

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

func (m *UndelegateRecord) GetRecords() []*UndelegateRecordContent {
	if m != nil {
		return m.Records
	}
	return nil
}

type UndelegateRecordContent struct {
	Withdrawer        string                                 `protobuf:"bytes,1,opt,name=withdrawer,proto3" json:"withdrawer,omitempty"`
	SnAssetAmount     *types.Coin                            `protobuf:"bytes,2,opt,name=sn_asset_amount,json=snAssetAmount,proto3" json:"sn_asset_amount,omitempty"`
	WithdrawAmount    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=withdraw_amount,json=withdrawAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"withdraw_amount"`
	State             int64                                  `protobuf:"varint,4,opt,name=state,proto3" json:"state,omitempty"`
	OracleVersion     uint64                                 `protobuf:"varint,5,opt,name=oracle_version,json=oracleVersion,proto3" json:"oracle_version,omitempty"`
	UndelegateVersion uint64                                 `protobuf:"varint,6,opt,name=undelegate_version,json=undelegateVersion,proto3" json:"undelegate_version,omitempty"`
}

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

var xxx_messageInfo_UndelegateRecordContent proto.InternalMessageInfo

func (m *UndelegateRecordContent) GetWithdrawer() string {
	if m != nil {
		return m.Withdrawer
	}
	return ""
}

func (m *UndelegateRecordContent) GetSnAssetAmount() *types.Coin {
	if m != nil {
		return m.SnAssetAmount
	}
	return nil
}

func (m *UndelegateRecordContent) GetState() int64 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *UndelegateRecordContent) GetOracleVersion() uint64 {
	if m != nil {
		return m.OracleVersion
	}
	return 0
}

func (m *UndelegateRecordContent) GetUndelegateVersion() uint64 {
	if m != nil {
		return m.UndelegateVersion
	}
	return 0
}

type WithdrawRecord struct {
	ZoneId     string                            `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
	Withdrawer string                            `protobuf:"bytes,2,opt,name=withdrawer,proto3" json:"withdrawer,omitempty"`
	Records    map[uint64]*WithdrawRecordContent `protobuf:"bytes,3,rep,name=records,proto3" json:"records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *WithdrawRecord) Reset()         { *m = WithdrawRecord{} }
func (m *WithdrawRecord) String() string { return proto.CompactTextString(m) }
func (*WithdrawRecord) ProtoMessage()    {}
func (*WithdrawRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_995e5185773ac6e7, []int{6}
}
func (m *WithdrawRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WithdrawRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WithdrawRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WithdrawRecord.Merge(m, src)
}
func (m *WithdrawRecord) XXX_Size() int {
	return m.Size()
}
func (m *WithdrawRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_WithdrawRecord.DiscardUnknown(m)
}

var xxx_messageInfo_WithdrawRecord proto.InternalMessageInfo

func (m *WithdrawRecord) GetZoneId() string {
	if m != nil {
		return m.ZoneId
	}
	return ""
}

func (m *WithdrawRecord) GetWithdrawer() string {
	if m != nil {
		return m.Withdrawer
	}
	return ""
}

func (m *WithdrawRecord) GetRecords() map[uint64]*WithdrawRecordContent {
	if m != nil {
		return m.Records
	}
	return nil
}

type WithdrawRecordContent struct {
	Amount          github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	UnstakingAmount *types.Coin                            `protobuf:"bytes,2,opt,name=unstaking_amount,json=unstakingAmount,proto3" json:"unstaking_amount,omitempty"`
	State           int64                                  `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
	OracleVersion   int64                                  `protobuf:"varint,4,opt,name=oracle_version,json=oracleVersion,proto3" json:"oracle_version,omitempty"`
	WithdrawVersion uint64                                 `protobuf:"varint,5,opt,name=withdraw_version,json=withdrawVersion,proto3" json:"withdraw_version,omitempty"`
	CompletionTime  time.Time                              `protobuf:"bytes,6,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"`
}

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

var xxx_messageInfo_WithdrawRecordContent proto.InternalMessageInfo

func (m *WithdrawRecordContent) GetUnstakingAmount() *types.Coin {
	if m != nil {
		return m.UnstakingAmount
	}
	return nil
}

func (m *WithdrawRecordContent) GetState() int64 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *WithdrawRecordContent) GetOracleVersion() int64 {
	if m != nil {
		return m.OracleVersion
	}
	return 0
}

func (m *WithdrawRecordContent) GetWithdrawVersion() uint64 {
	if m != nil {
		return m.WithdrawVersion
	}
	return 0
}

func (m *WithdrawRecordContent) GetCompletionTime() time.Time {
	if m != nil {
		return m.CompletionTime
	}
	return time.Time{}
}

func init() {
	proto.RegisterType((*DepositRecord)(nil), "nova.gal.v1.DepositRecord")
	proto.RegisterType((*DepositRecordContent)(nil), "nova.gal.v1.DepositRecordContent")
	proto.RegisterType((*DelegateRecord)(nil), "nova.gal.v1.DelegateRecord")
	proto.RegisterMapType((map[uint64]*DelegateRecordContent)(nil), "nova.gal.v1.DelegateRecord.RecordsEntry")
	proto.RegisterType((*DelegateRecordContent)(nil), "nova.gal.v1.DelegateRecordContent")
	proto.RegisterType((*UndelegateRecord)(nil), "nova.gal.v1.UndelegateRecord")
	proto.RegisterType((*UndelegateRecordContent)(nil), "nova.gal.v1.UndelegateRecordContent")
	proto.RegisterType((*WithdrawRecord)(nil), "nova.gal.v1.WithdrawRecord")
	proto.RegisterMapType((map[uint64]*WithdrawRecordContent)(nil), "nova.gal.v1.WithdrawRecord.RecordsEntry")
	proto.RegisterType((*WithdrawRecordContent)(nil), "nova.gal.v1.WithdrawRecordContent")
}

func init() { proto.RegisterFile("nova/gal/v1/gal.proto", fileDescriptor_995e5185773ac6e7) }

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

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 len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGal(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Depositor) > 0 {
		i -= len(m.Depositor)
		copy(dAtA[i:], m.Depositor)
		i = encodeVarintGal(dAtA, i, uint64(len(m.Depositor)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ZoneId) > 0 {
		i -= len(m.ZoneId)
		copy(dAtA[i:], m.ZoneId)
		i = encodeVarintGal(dAtA, i, uint64(len(m.ZoneId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DepositRecordContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if m.Amount != nil {
		{
			size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGal(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Claimer) > 0 {
		i -= len(m.Claimer)
		copy(dAtA[i:], m.Claimer)
		i = encodeVarintGal(dAtA, i, uint64(len(m.Claimer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DelegateRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Records) > 0 {
		keysForRecords := make([]uint64, 0, len(m.Records))
		for k := range m.Records {
			keysForRecords = append(keysForRecords, uint64(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint64s(keysForRecords)
		for iNdEx := len(keysForRecords) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Records[uint64(keysForRecords[iNdEx])]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGal(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintGal(dAtA, i, uint64(keysForRecords[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintGal(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Claimer) > 0 {
		i -= len(m.Claimer)
		copy(dAtA[i:], m.Claimer)
		i = encodeVarintGal(dAtA, i, uint64(len(m.Claimer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ZoneId) > 0 {
		i -= len(m.ZoneId)
		copy(dAtA[i:], m.ZoneId)
		i = encodeVarintGal(dAtA, i, uint64(len(m.ZoneId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DelegateRecordContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OracleVersion != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.OracleVersion))
		i--
		dAtA[i] = 0x18
	}
	if m.State != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	if m.Amount != nil {
		{
			size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGal(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *UndelegateRecordContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UndelegateVersion != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.UndelegateVersion))
		i--
		dAtA[i] = 0x30
	}
	if m.OracleVersion != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.OracleVersion))
		i--
		dAtA[i] = 0x28
	}
	if m.State != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.WithdrawAmount.Size()
		i -= size
		if _, err := m.WithdrawAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGal(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.SnAssetAmount != nil {
		{
			size, err := m.SnAssetAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGal(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Withdrawer) > 0 {
		i -= len(m.Withdrawer)
		copy(dAtA[i:], m.Withdrawer)
		i = encodeVarintGal(dAtA, i, uint64(len(m.Withdrawer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *WithdrawRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Records) > 0 {
		keysForRecords := make([]uint64, 0, len(m.Records))
		for k := range m.Records {
			keysForRecords = append(keysForRecords, uint64(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint64s(keysForRecords)
		for iNdEx := len(keysForRecords) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Records[uint64(keysForRecords[iNdEx])]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGal(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintGal(dAtA, i, uint64(keysForRecords[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintGal(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Withdrawer) > 0 {
		i -= len(m.Withdrawer)
		copy(dAtA[i:], m.Withdrawer)
		i = encodeVarintGal(dAtA, i, uint64(len(m.Withdrawer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ZoneId) > 0 {
		i -= len(m.ZoneId)
		copy(dAtA[i:], m.ZoneId)
		i = encodeVarintGal(dAtA, i, uint64(len(m.ZoneId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *WithdrawRecordContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintGal(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x32
	if m.WithdrawVersion != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.WithdrawVersion))
		i--
		dAtA[i] = 0x28
	}
	if m.OracleVersion != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.OracleVersion))
		i--
		dAtA[i] = 0x20
	}
	if m.State != 0 {
		i = encodeVarintGal(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if m.UnstakingAmount != nil {
		{
			size, err := m.UnstakingAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGal(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGal(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintGal(dAtA []byte, offset int, v uint64) int {
	offset -= sovGal(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DepositRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ZoneId)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	l = len(m.Depositor)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovGal(uint64(l))
		}
	}
	return n
}

func (m *DepositRecordContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Claimer)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if m.Amount != nil {
		l = m.Amount.Size()
		n += 1 + l + sovGal(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovGal(uint64(m.State))
	}
	return n
}

func (m *DelegateRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ZoneId)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	l = len(m.Claimer)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if len(m.Records) > 0 {
		for k, v := range m.Records {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGal(uint64(l))
			}
			mapEntrySize := 1 + sovGal(uint64(k)) + l
			n += mapEntrySize + 1 + sovGal(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *DelegateRecordContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Amount != nil {
		l = m.Amount.Size()
		n += 1 + l + sovGal(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovGal(uint64(m.State))
	}
	if m.OracleVersion != 0 {
		n += 1 + sovGal(uint64(m.OracleVersion))
	}
	return n
}

func (m *UndelegateRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ZoneId)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovGal(uint64(l))
		}
	}
	return n
}

func (m *UndelegateRecordContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Withdrawer)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if m.SnAssetAmount != nil {
		l = m.SnAssetAmount.Size()
		n += 1 + l + sovGal(uint64(l))
	}
	l = m.WithdrawAmount.Size()
	n += 1 + l + sovGal(uint64(l))
	if m.State != 0 {
		n += 1 + sovGal(uint64(m.State))
	}
	if m.OracleVersion != 0 {
		n += 1 + sovGal(uint64(m.OracleVersion))
	}
	if m.UndelegateVersion != 0 {
		n += 1 + sovGal(uint64(m.UndelegateVersion))
	}
	return n
}

func (m *WithdrawRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ZoneId)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	l = len(m.Withdrawer)
	if l > 0 {
		n += 1 + l + sovGal(uint64(l))
	}
	if len(m.Records) > 0 {
		for k, v := range m.Records {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGal(uint64(l))
			}
			mapEntrySize := 1 + sovGal(uint64(k)) + l
			n += mapEntrySize + 1 + sovGal(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *WithdrawRecordContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Amount.Size()
	n += 1 + l + sovGal(uint64(l))
	if m.UnstakingAmount != nil {
		l = m.UnstakingAmount.Size()
		n += 1 + l + sovGal(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovGal(uint64(m.State))
	}
	if m.OracleVersion != 0 {
		n += 1 + sovGal(uint64(m.OracleVersion))
	}
	if m.WithdrawVersion != 0 {
		n += 1 + sovGal(uint64(m.WithdrawVersion))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
	n += 1 + l + sovGal(uint64(l))
	return n
}

func sovGal(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGal(x uint64) (n int) {
	return sovGal(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
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 ErrIntOverflowGal
			}
			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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depositor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Depositor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Records = append(m.Records, &DepositRecordContent{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateRecord) 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 ErrIntOverflowGal
			}
			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: DelegateRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Claimer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Claimer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Records == nil {
				m.Records = make(map[uint64]*DelegateRecordContent)
			}
			var mapkey uint64
			var mapvalue *DelegateRecordContent
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGal
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGal
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGal
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGal
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGal
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &DelegateRecordContent{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGal(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGal
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Records[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateRecordContent) 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 ErrIntOverflowGal
			}
			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: DelegateRecordContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateRecordContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Amount == nil {
				m.Amount = &types.Coin{}
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleVersion", wireType)
			}
			m.OracleVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UndelegateRecordContent) 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 ErrIntOverflowGal
			}
			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: UndelegateRecordContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UndelegateRecordContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withdrawer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Withdrawer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnAssetAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SnAssetAmount == nil {
				m.SnAssetAmount = &types.Coin{}
			}
			if err := m.SnAssetAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.WithdrawAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleVersion", wireType)
			}
			m.OracleVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UndelegateVersion", wireType)
			}
			m.UndelegateVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UndelegateVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WithdrawRecord) 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 ErrIntOverflowGal
			}
			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: WithdrawRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WithdrawRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withdrawer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Withdrawer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Records == nil {
				m.Records = make(map[uint64]*WithdrawRecordContent)
			}
			var mapkey uint64
			var mapvalue *WithdrawRecordContent
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGal
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGal
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGal
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGal
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGal
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &WithdrawRecordContent{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGal(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGal
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Records[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WithdrawRecordContent) 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 ErrIntOverflowGal
			}
			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: WithdrawRecordContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WithdrawRecordContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				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 ErrInvalidLengthGal
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnstakingAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnstakingAmount == nil {
				m.UnstakingAmount = &types.Coin{}
			}
			if err := m.UnstakingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleVersion", wireType)
			}
			m.OracleVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawVersion", wireType)
			}
			m.WithdrawVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WithdrawVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGal
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGal
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthGal        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGal          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGal = fmt.Errorf("proto: unexpected end of group")
)