Channel.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: core/04-channel/Channel.proto

package channel

import (
	fmt "fmt"
	_ "github.com/datachainlab/solidity-protobuf/protobuf-solidity/src/protoc/go"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	client "github.com/hyperledger-labs/yui-ibc-solidity/pkg/ibc/core/client"
	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

// State defines if a channel is in one of the following states:
// CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED.
type Channel_State int32

const (
	// Default State
	UNINITIALIZED Channel_State = 0
	// A channel has just started the opening handshake.
	INIT Channel_State = 1
	// A channel has acknowledged the handshake step on the counterparty chain.
	TRYOPEN Channel_State = 2
	// A channel has completed the handshake. Open channels are
	// ready to send and receive packets.
	OPEN Channel_State = 3
	// A channel has been closed and can no longer be used to send or receive
	// packets.
	CLOSED Channel_State = 4
	// A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets.
	FLUSHING Channel_State = 5
	// A channel has just completed flushing any in-flight packets.
	FLUSHCOMPLETE Channel_State = 6
)

var Channel_State_name = map[int32]string{
	0: "STATE_UNINITIALIZED_UNSPECIFIED",
	1: "STATE_INIT",
	2: "STATE_TRYOPEN",
	3: "STATE_OPEN",
	4: "STATE_CLOSED",
	5: "STATE_FLUSHING",
	6: "STATE_FLUSHCOMPLETE",
}

var Channel_State_value = map[string]int32{
	"STATE_UNINITIALIZED_UNSPECIFIED": 0,
	"STATE_INIT":                      1,
	"STATE_TRYOPEN":                   2,
	"STATE_OPEN":                      3,
	"STATE_CLOSED":                    4,
	"STATE_FLUSHING":                  5,
	"STATE_FLUSHCOMPLETE":             6,
}

func (x Channel_State) String() string {
	return proto.EnumName(Channel_State_name, int32(x))
}

func (Channel_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2f64d8fe59dd9c38, []int{0, 0}
}

// Order defines if a channel is ORDERED or UNORDERED
type Channel_Order int32

const (
	// zero-value for channel ordering
	NONE Channel_Order = 0
	// packets can be delivered in any order, which may differ from the order in
	// which they were sent.
	UNORDERED Channel_Order = 1
	// packets are delivered exactly in the order which they were sent
	ORDERED Channel_Order = 2
)

var Channel_Order_name = map[int32]string{
	0: "ORDER_NONE_UNSPECIFIED",
	1: "ORDER_UNORDERED",
	2: "ORDER_ORDERED",
}

var Channel_Order_value = map[string]int32{
	"ORDER_NONE_UNSPECIFIED": 0,
	"ORDER_UNORDERED":        1,
	"ORDER_ORDERED":          2,
}

func (x Channel_Order) String() string {
	return proto.EnumName(Channel_Order_name, int32(x))
}

func (Channel_Order) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2f64d8fe59dd9c38, []int{0, 1}
}

// Channel defines pipeline for exactly-once packet delivery between specific
// modules on separate blockchains, which has at least one end capable of
// sending packets and one end capable of receiving packets.
type Channel struct {
	// current state of the channel end
	State Channel_State `protobuf:"varint,1,opt,name=state,proto3,enum=Channel_State" json:"state,omitempty"`
	// whether the channel is ordered or unordered
	Ordering Channel_Order `protobuf:"varint,2,opt,name=ordering,proto3,enum=Channel_Order" json:"ordering,omitempty"`
	// counterparty channel end
	Counterparty Channel_Counterparty `protobuf:"bytes,3,opt,name=counterparty,proto3" json:"counterparty"`
	// list of connection identifiers, in order, along which packets sent on
	// this channel will travel
	ConnectionHops []string `protobuf:"bytes,4,rep,name=connection_hops,json=connectionHops,proto3" json:"connection_hops,omitempty" yaml:"connection_hops"`
	// opaque channel version, which is agreed upon during the handshake
	Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
	// upgrade sequence indicates the latest upgrade attempt performed by this channel
	// the value of 0 indicates the channel has never been upgraded
	UpgradeSequence uint64 `protobuf:"varint,6,opt,name=upgrade_sequence,json=upgradeSequence,proto3" json:"upgrade_sequence,omitempty"`
}

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

var xxx_messageInfo_Channel proto.InternalMessageInfo

// Counterparty defines a channel end counterparty
type Channel_Counterparty struct {
	// port on the counterparty chain which owns the other end of the channel.
	PortId string `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty" yaml:"port_id"`
	// channel end on the counterparty chain
	ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" yaml:"channel_id"`
}

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

var xxx_messageInfo_Channel_Counterparty proto.InternalMessageInfo

// Timeout defines an execution deadline structure for 04-channel handlers.
// This includes packet lifecycle handlers as well as the upgrade handshake handlers.
// A valid Timeout contains either one or both of a timestamp and block height (sequence).
type Timeout struct {
	// block height after which the packet or upgrade times out
	Height client.Height `protobuf:"bytes,1,opt,name=height,proto3" json:"height"`
	// block timestamp (in nanoseconds) after which the packet or upgrade times out
	Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_Timeout proto.InternalMessageInfo

func (m *Timeout) GetHeight() client.Height {
	if m != nil {
		return m.Height
	}
	return client.Height{}
}

func (m *Timeout) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

// Upgrade is a verifiable type which contains the relevant information
// for an attempted upgrade. It provides the proposed changes to the channel
// end, the timeout for this upgrade attempt and the next packet sequence
// which allows the counterparty to efficiently know the highest sequence it has received.
// The next sequence send is used for pruning and upgrading from unordered to ordered channels.
type Upgrade struct {
	Fields           UpgradeFields `protobuf:"bytes,1,opt,name=fields,proto3" json:"fields"`
	Timeout          Timeout       `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout"`
	NextSequenceSend uint64        `protobuf:"varint,3,opt,name=next_sequence_send,json=nextSequenceSend,proto3" json:"next_sequence_send,omitempty"`
}

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

var xxx_messageInfo_Upgrade proto.InternalMessageInfo

// UpgradeFields are the fields in a channel end which may be changed
// during a channel upgrade.
type UpgradeFields struct {
	Ordering       Channel_Order `protobuf:"varint,1,opt,name=ordering,proto3,enum=Channel_Order" json:"ordering,omitempty"`
	ConnectionHops []string      `protobuf:"bytes,2,rep,name=connection_hops,json=connectionHops,proto3" json:"connection_hops,omitempty"`
	Version        string        `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_UpgradeFields proto.InternalMessageInfo

// ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the
// upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the
// next sequence.
type ErrorReceipt struct {
	// the channel upgrade sequence
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// the error message detailing the cause of failure
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_ErrorReceipt proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("Channel_State", Channel_State_name, Channel_State_value)
	proto.RegisterEnum("Channel_Order", Channel_Order_name, Channel_Order_value)
	proto.RegisterType((*Channel)(nil), "Channel")
	proto.RegisterType((*Channel_Counterparty)(nil), "Channel.Counterparty")
	proto.RegisterType((*Timeout)(nil), "Timeout")
	proto.RegisterType((*Upgrade)(nil), "Upgrade")
	proto.RegisterType((*UpgradeFields)(nil), "UpgradeFields")
	proto.RegisterType((*ErrorReceipt)(nil), "ErrorReceipt")
}

func init() { proto.RegisterFile("core/04-channel/Channel.proto", fileDescriptor_2f64d8fe59dd9c38) }

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

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

func (m *Channel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpgradeSequence != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.UpgradeSequence))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintChannel(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ConnectionHops) > 0 {
		for iNdEx := len(m.ConnectionHops) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ConnectionHops[iNdEx])
			copy(dAtA[i:], m.ConnectionHops[iNdEx])
			i = encodeVarintChannel(dAtA, i, uint64(len(m.ConnectionHops[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	{
		size, err := m.Counterparty.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintChannel(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Ordering != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.Ordering))
		i--
		dAtA[i] = 0x10
	}
	if m.State != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Timeout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintChannel(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Upgrade) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextSequenceSend != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.NextSequenceSend))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Timeout.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintChannel(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintChannel(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *UpgradeFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintChannel(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ConnectionHops) > 0 {
		for iNdEx := len(m.ConnectionHops) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ConnectionHops[iNdEx])
			copy(dAtA[i:], m.ConnectionHops[iNdEx])
			i = encodeVarintChannel(dAtA, i, uint64(len(m.ConnectionHops[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Ordering != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.Ordering))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ErrorReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintChannel(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Sequence != 0 {
		i = encodeVarintChannel(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintChannel(dAtA []byte, offset int, v uint64) int {
	offset -= sovChannel(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Channel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != 0 {
		n += 1 + sovChannel(uint64(m.State))
	}
	if m.Ordering != 0 {
		n += 1 + sovChannel(uint64(m.Ordering))
	}
	l = m.Counterparty.Size()
	n += 1 + l + sovChannel(uint64(l))
	if len(m.ConnectionHops) > 0 {
		for _, s := range m.ConnectionHops {
			l = len(s)
			n += 1 + l + sovChannel(uint64(l))
		}
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovChannel(uint64(l))
	}
	if m.UpgradeSequence != 0 {
		n += 1 + sovChannel(uint64(m.UpgradeSequence))
	}
	return n
}

func (m *Channel_Counterparty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovChannel(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovChannel(uint64(l))
	}
	return n
}

func (m *Timeout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Height.Size()
	n += 1 + l + sovChannel(uint64(l))
	if m.Timestamp != 0 {
		n += 1 + sovChannel(uint64(m.Timestamp))
	}
	return n
}

func (m *Upgrade) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Fields.Size()
	n += 1 + l + sovChannel(uint64(l))
	l = m.Timeout.Size()
	n += 1 + l + sovChannel(uint64(l))
	if m.NextSequenceSend != 0 {
		n += 1 + sovChannel(uint64(m.NextSequenceSend))
	}
	return n
}

func (m *UpgradeFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ordering != 0 {
		n += 1 + sovChannel(uint64(m.Ordering))
	}
	if len(m.ConnectionHops) > 0 {
		for _, s := range m.ConnectionHops {
			l = len(s)
			n += 1 + l + sovChannel(uint64(l))
		}
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovChannel(uint64(l))
	}
	return n
}

func (m *ErrorReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovChannel(uint64(m.Sequence))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovChannel(uint64(l))
	}
	return n
}

func sovChannel(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozChannel(x uint64) (n int) {
	return sovChannel(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Channel) 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 ErrIntOverflowChannel
			}
			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: Channel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Channel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowChannel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= Channel_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ordering", wireType)
			}
			m.Ordering = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChannel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ordering |= Channel_Order(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counterparty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChannel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChannel
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChannel
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Counterparty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionHops", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChannel
				}
				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 ErrInvalidLengthChannel
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChannel
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConnectionHops = append(m.ConnectionHops, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChannel
				}
				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 ErrInvalidLengthChannel
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChannel
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpgradeSequence", wireType)
			}
			m.UpgradeSequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChannel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpgradeSequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipChannel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChannel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

var (
	ErrInvalidLengthChannel        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowChannel          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupChannel = fmt.Errorf("proto: unexpected end of group")
)