github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/p2p/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/p2p/types.proto 3 4 package p2p 5 6 import ( 7 fmt "fmt" 8 _ "github.com/gogo/protobuf/gogoproto" 9 proto "github.com/gogo/protobuf/proto" 10 io "io" 11 math "math" 12 math_bits "math/bits" 13 ) 14 15 // Reference imports to suppress errors if they are not otherwise used. 16 var _ = proto.Marshal 17 var _ = fmt.Errorf 18 var _ = math.Inf 19 20 // This is a compile-time assertion to ensure that this generated file 21 // is compatible with the proto package it is being compiled against. 22 // A compilation error at this line likely means your copy of the 23 // proto package needs to be updated. 24 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 25 26 type NetAddress struct { 27 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 28 IP string `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"` 29 Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"` 30 } 31 32 func (m *NetAddress) Reset() { *m = NetAddress{} } 33 func (m *NetAddress) String() string { return proto.CompactTextString(m) } 34 func (*NetAddress) ProtoMessage() {} 35 func (*NetAddress) Descriptor() ([]byte, []int) { 36 return fileDescriptor_c8a29e659aeca578, []int{0} 37 } 38 func (m *NetAddress) XXX_Unmarshal(b []byte) error { 39 return m.Unmarshal(b) 40 } 41 func (m *NetAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 42 if deterministic { 43 return xxx_messageInfo_NetAddress.Marshal(b, m, deterministic) 44 } else { 45 b = b[:cap(b)] 46 n, err := m.MarshalToSizedBuffer(b) 47 if err != nil { 48 return nil, err 49 } 50 return b[:n], nil 51 } 52 } 53 func (m *NetAddress) XXX_Merge(src proto.Message) { 54 xxx_messageInfo_NetAddress.Merge(m, src) 55 } 56 func (m *NetAddress) XXX_Size() int { 57 return m.Size() 58 } 59 func (m *NetAddress) XXX_DiscardUnknown() { 60 xxx_messageInfo_NetAddress.DiscardUnknown(m) 61 } 62 63 var xxx_messageInfo_NetAddress proto.InternalMessageInfo 64 65 func (m *NetAddress) GetID() string { 66 if m != nil { 67 return m.ID 68 } 69 return "" 70 } 71 72 func (m *NetAddress) GetIP() string { 73 if m != nil { 74 return m.IP 75 } 76 return "" 77 } 78 79 func (m *NetAddress) GetPort() uint32 { 80 if m != nil { 81 return m.Port 82 } 83 return 0 84 } 85 86 type ProtocolVersion struct { 87 P2P uint64 `protobuf:"varint,1,opt,name=p2p,proto3" json:"p2p,omitempty"` 88 Block uint64 `protobuf:"varint,2,opt,name=block,proto3" json:"block,omitempty"` 89 App uint64 `protobuf:"varint,3,opt,name=app,proto3" json:"app,omitempty"` 90 } 91 92 func (m *ProtocolVersion) Reset() { *m = ProtocolVersion{} } 93 func (m *ProtocolVersion) String() string { return proto.CompactTextString(m) } 94 func (*ProtocolVersion) ProtoMessage() {} 95 func (*ProtocolVersion) Descriptor() ([]byte, []int) { 96 return fileDescriptor_c8a29e659aeca578, []int{1} 97 } 98 func (m *ProtocolVersion) XXX_Unmarshal(b []byte) error { 99 return m.Unmarshal(b) 100 } 101 func (m *ProtocolVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 102 if deterministic { 103 return xxx_messageInfo_ProtocolVersion.Marshal(b, m, deterministic) 104 } else { 105 b = b[:cap(b)] 106 n, err := m.MarshalToSizedBuffer(b) 107 if err != nil { 108 return nil, err 109 } 110 return b[:n], nil 111 } 112 } 113 func (m *ProtocolVersion) XXX_Merge(src proto.Message) { 114 xxx_messageInfo_ProtocolVersion.Merge(m, src) 115 } 116 func (m *ProtocolVersion) XXX_Size() int { 117 return m.Size() 118 } 119 func (m *ProtocolVersion) XXX_DiscardUnknown() { 120 xxx_messageInfo_ProtocolVersion.DiscardUnknown(m) 121 } 122 123 var xxx_messageInfo_ProtocolVersion proto.InternalMessageInfo 124 125 func (m *ProtocolVersion) GetP2P() uint64 { 126 if m != nil { 127 return m.P2P 128 } 129 return 0 130 } 131 132 func (m *ProtocolVersion) GetBlock() uint64 { 133 if m != nil { 134 return m.Block 135 } 136 return 0 137 } 138 139 func (m *ProtocolVersion) GetApp() uint64 { 140 if m != nil { 141 return m.App 142 } 143 return 0 144 } 145 146 type DefaultNodeInfo struct { 147 ProtocolVersion ProtocolVersion `protobuf:"bytes,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version"` 148 DefaultNodeID string `protobuf:"bytes,2,opt,name=default_node_id,json=defaultNodeId,proto3" json:"default_node_id,omitempty"` 149 ListenAddr string `protobuf:"bytes,3,opt,name=listen_addr,json=listenAddr,proto3" json:"listen_addr,omitempty"` 150 Network string `protobuf:"bytes,4,opt,name=network,proto3" json:"network,omitempty"` 151 Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` 152 Channels []byte `protobuf:"bytes,6,opt,name=channels,proto3" json:"channels,omitempty"` 153 Moniker string `protobuf:"bytes,7,opt,name=moniker,proto3" json:"moniker,omitempty"` 154 Other DefaultNodeInfoOther `protobuf:"bytes,8,opt,name=other,proto3" json:"other"` 155 } 156 157 func (m *DefaultNodeInfo) Reset() { *m = DefaultNodeInfo{} } 158 func (m *DefaultNodeInfo) String() string { return proto.CompactTextString(m) } 159 func (*DefaultNodeInfo) ProtoMessage() {} 160 func (*DefaultNodeInfo) Descriptor() ([]byte, []int) { 161 return fileDescriptor_c8a29e659aeca578, []int{2} 162 } 163 func (m *DefaultNodeInfo) XXX_Unmarshal(b []byte) error { 164 return m.Unmarshal(b) 165 } 166 func (m *DefaultNodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 167 if deterministic { 168 return xxx_messageInfo_DefaultNodeInfo.Marshal(b, m, deterministic) 169 } else { 170 b = b[:cap(b)] 171 n, err := m.MarshalToSizedBuffer(b) 172 if err != nil { 173 return nil, err 174 } 175 return b[:n], nil 176 } 177 } 178 func (m *DefaultNodeInfo) XXX_Merge(src proto.Message) { 179 xxx_messageInfo_DefaultNodeInfo.Merge(m, src) 180 } 181 func (m *DefaultNodeInfo) XXX_Size() int { 182 return m.Size() 183 } 184 func (m *DefaultNodeInfo) XXX_DiscardUnknown() { 185 xxx_messageInfo_DefaultNodeInfo.DiscardUnknown(m) 186 } 187 188 var xxx_messageInfo_DefaultNodeInfo proto.InternalMessageInfo 189 190 func (m *DefaultNodeInfo) GetProtocolVersion() ProtocolVersion { 191 if m != nil { 192 return m.ProtocolVersion 193 } 194 return ProtocolVersion{} 195 } 196 197 func (m *DefaultNodeInfo) GetDefaultNodeID() string { 198 if m != nil { 199 return m.DefaultNodeID 200 } 201 return "" 202 } 203 204 func (m *DefaultNodeInfo) GetListenAddr() string { 205 if m != nil { 206 return m.ListenAddr 207 } 208 return "" 209 } 210 211 func (m *DefaultNodeInfo) GetNetwork() string { 212 if m != nil { 213 return m.Network 214 } 215 return "" 216 } 217 218 func (m *DefaultNodeInfo) GetVersion() string { 219 if m != nil { 220 return m.Version 221 } 222 return "" 223 } 224 225 func (m *DefaultNodeInfo) GetChannels() []byte { 226 if m != nil { 227 return m.Channels 228 } 229 return nil 230 } 231 232 func (m *DefaultNodeInfo) GetMoniker() string { 233 if m != nil { 234 return m.Moniker 235 } 236 return "" 237 } 238 239 func (m *DefaultNodeInfo) GetOther() DefaultNodeInfoOther { 240 if m != nil { 241 return m.Other 242 } 243 return DefaultNodeInfoOther{} 244 } 245 246 type DefaultNodeInfoOther struct { 247 TxIndex string `protobuf:"bytes,1,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"` 248 RPCAddress string `protobuf:"bytes,2,opt,name=rpc_address,json=rpcAddress,proto3" json:"rpc_address,omitempty"` 249 } 250 251 func (m *DefaultNodeInfoOther) Reset() { *m = DefaultNodeInfoOther{} } 252 func (m *DefaultNodeInfoOther) String() string { return proto.CompactTextString(m) } 253 func (*DefaultNodeInfoOther) ProtoMessage() {} 254 func (*DefaultNodeInfoOther) Descriptor() ([]byte, []int) { 255 return fileDescriptor_c8a29e659aeca578, []int{3} 256 } 257 func (m *DefaultNodeInfoOther) XXX_Unmarshal(b []byte) error { 258 return m.Unmarshal(b) 259 } 260 func (m *DefaultNodeInfoOther) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 261 if deterministic { 262 return xxx_messageInfo_DefaultNodeInfoOther.Marshal(b, m, deterministic) 263 } else { 264 b = b[:cap(b)] 265 n, err := m.MarshalToSizedBuffer(b) 266 if err != nil { 267 return nil, err 268 } 269 return b[:n], nil 270 } 271 } 272 func (m *DefaultNodeInfoOther) XXX_Merge(src proto.Message) { 273 xxx_messageInfo_DefaultNodeInfoOther.Merge(m, src) 274 } 275 func (m *DefaultNodeInfoOther) XXX_Size() int { 276 return m.Size() 277 } 278 func (m *DefaultNodeInfoOther) XXX_DiscardUnknown() { 279 xxx_messageInfo_DefaultNodeInfoOther.DiscardUnknown(m) 280 } 281 282 var xxx_messageInfo_DefaultNodeInfoOther proto.InternalMessageInfo 283 284 func (m *DefaultNodeInfoOther) GetTxIndex() string { 285 if m != nil { 286 return m.TxIndex 287 } 288 return "" 289 } 290 291 func (m *DefaultNodeInfoOther) GetRPCAddress() string { 292 if m != nil { 293 return m.RPCAddress 294 } 295 return "" 296 } 297 298 func init() { 299 proto.RegisterType((*NetAddress)(nil), "tendermint.p2p.NetAddress") 300 proto.RegisterType((*ProtocolVersion)(nil), "tendermint.p2p.ProtocolVersion") 301 proto.RegisterType((*DefaultNodeInfo)(nil), "tendermint.p2p.DefaultNodeInfo") 302 proto.RegisterType((*DefaultNodeInfoOther)(nil), "tendermint.p2p.DefaultNodeInfoOther") 303 } 304 305 func init() { proto.RegisterFile("tendermint/p2p/types.proto", fileDescriptor_c8a29e659aeca578) } 306 307 var fileDescriptor_c8a29e659aeca578 = []byte{ 308 // 503 bytes of a gzipped FileDescriptorProto 309 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x53, 0x4d, 0x6f, 0xda, 0x40, 310 0x10, 0xc5, 0xc6, 0x7c, 0x64, 0x28, 0x21, 0x5d, 0xa1, 0xca, 0xe1, 0x60, 0x23, 0xd4, 0x03, 0x27, 311 0x2c, 0x91, 0x5e, 0x7a, 0x6b, 0x09, 0x87, 0x72, 0x49, 0xad, 0x55, 0xd4, 0x43, 0x2f, 0xc8, 0x78, 312 0x37, 0xb0, 0x02, 0x76, 0x57, 0xeb, 0xa5, 0x25, 0xff, 0xa2, 0x3f, 0x2b, 0xc7, 0x1c, 0x7b, 0xb2, 313 0x2a, 0x73, 0xec, 0x9f, 0xa8, 0xbc, 0x76, 0x52, 0x82, 0x72, 0x9b, 0x37, 0x6f, 0x67, 0xde, 0xcc, 314 0xd3, 0x2c, 0xf4, 0x34, 0xe5, 0x84, 0xaa, 0x2d, 0xe3, 0x3a, 0x90, 0x63, 0x19, 0xe8, 0x7b, 0x49, 315 0x93, 0x91, 0x54, 0x42, 0x0b, 0x74, 0xfe, 0x9f, 0x1b, 0xc9, 0xb1, 0xec, 0x75, 0x97, 0x62, 0x29, 316 0x0c, 0x15, 0xe4, 0x51, 0xf1, 0x6a, 0x10, 0x02, 0xdc, 0x50, 0xfd, 0x99, 0x10, 0x45, 0x93, 0x04, 317 0xbd, 0x03, 0x9b, 0x11, 0xd7, 0xea, 0x5b, 0xc3, 0xb3, 0x49, 0x3d, 0x4b, 0x7d, 0x7b, 0x36, 0xc5, 318 0x36, 0x23, 0x26, 0x2f, 0x5d, 0xfb, 0x28, 0x1f, 0x62, 0x9b, 0x49, 0x84, 0xc0, 0x91, 0x42, 0x69, 319 0xb7, 0xda, 0xb7, 0x86, 0x6d, 0x6c, 0xe2, 0xc1, 0x2d, 0x74, 0xc2, 0xbc, 0x75, 0x2c, 0x36, 0xdf, 320 0xa8, 0x4a, 0x98, 0xe0, 0xe8, 0x12, 0xaa, 0x72, 0x2c, 0x4d, 0x5f, 0x67, 0xd2, 0xc8, 0x52, 0xbf, 321 0x1a, 0x8e, 0x43, 0x9c, 0xe7, 0x50, 0x17, 0x6a, 0x8b, 0x8d, 0x88, 0xd7, 0xa6, 0xb9, 0x83, 0x0b, 322 0x80, 0x2e, 0xa0, 0x1a, 0x49, 0x69, 0xda, 0x3a, 0x38, 0x0f, 0x07, 0x7f, 0x6d, 0xe8, 0x4c, 0xe9, 323 0x5d, 0xb4, 0xdb, 0xe8, 0x1b, 0x41, 0xe8, 0x8c, 0xdf, 0x09, 0x14, 0xc2, 0x85, 0x2c, 0x95, 0xe6, 324 0x3f, 0x0a, 0x29, 0xa3, 0xd1, 0x1a, 0xfb, 0xa3, 0x97, 0xcb, 0x8f, 0x4e, 0x26, 0x9a, 0x38, 0x0f, 325 0xa9, 0x5f, 0xc1, 0x1d, 0x79, 0x32, 0xe8, 0x47, 0xe8, 0x90, 0x42, 0x64, 0xce, 0x05, 0xa1, 0x73, 326 0x46, 0xca, 0xa5, 0xdf, 0x66, 0xa9, 0xdf, 0x3e, 0xd6, 0x9f, 0xe2, 0x36, 0x39, 0x82, 0x04, 0xf9, 327 0xd0, 0xda, 0xb0, 0x44, 0x53, 0x3e, 0x8f, 0x08, 0x51, 0x66, 0xf4, 0x33, 0x0c, 0x45, 0x2a, 0xb7, 328 0x17, 0xb9, 0xd0, 0xe0, 0x54, 0xff, 0x14, 0x6a, 0xed, 0x3a, 0x86, 0x7c, 0x82, 0x39, 0xf3, 0x34, 329 0x7e, 0xad, 0x60, 0x4a, 0x88, 0x7a, 0xd0, 0x8c, 0x57, 0x11, 0xe7, 0x74, 0x93, 0xb8, 0xf5, 0xbe, 330 0x35, 0x7c, 0x83, 0x9f, 0x71, 0x5e, 0xb5, 0x15, 0x9c, 0xad, 0xa9, 0x72, 0x1b, 0x45, 0x55, 0x09, 331 0xd1, 0x27, 0xa8, 0x09, 0xbd, 0xa2, 0xca, 0x6d, 0x1a, 0x33, 0xde, 0x9f, 0x9a, 0x71, 0xe2, 0xe3, 332 0xd7, 0xfc, 0x6d, 0xe9, 0x48, 0x51, 0x38, 0x58, 0x40, 0xf7, 0xb5, 0x47, 0xe8, 0x12, 0x9a, 0x7a, 333 0x3f, 0x67, 0x9c, 0xd0, 0x7d, 0x71, 0x25, 0xb8, 0xa1, 0xf7, 0xb3, 0x1c, 0xa2, 0x00, 0x5a, 0x4a, 334 0xc6, 0x66, 0x79, 0x9a, 0x24, 0xa5, 0x6d, 0xe7, 0x59, 0xea, 0x03, 0x0e, 0xaf, 0xcb, 0xfb, 0xc2, 335 0xa0, 0x64, 0x5c, 0xc6, 0x93, 0xc5, 0x43, 0xe6, 0x59, 0x8f, 0x99, 0x67, 0xfd, 0xc9, 0x3c, 0xeb, 336 0xd7, 0xc1, 0xab, 0x3c, 0x1e, 0xbc, 0xca, 0xef, 0x83, 0x57, 0xf9, 0xfe, 0x65, 0xc9, 0xf4, 0x6a, 337 0xb7, 0x18, 0xc5, 0x62, 0x1b, 0x24, 0x3b, 0xa9, 0xa2, 0xe5, 0x7d, 0x14, 0xdc, 0x3e, 0xef, 0x70, 338 0x2d, 0x38, 0xa7, 0xb1, 0x16, 0x2a, 0x88, 0x57, 0x11, 0xe3, 0x49, 0xa0, 0xb7, 0x57, 0x1f, 0x82, 339 0xe2, 0xb2, 0x5f, 0xfe, 0x87, 0x45, 0xdd, 0x64, 0xaf, 0xfe, 0x05, 0x00, 0x00, 0xff, 0xff, 0x99, 340 0xd9, 0xb4, 0x6b, 0x28, 0x03, 0x00, 0x00, 341 } 342 343 func (m *NetAddress) Marshal() (dAtA []byte, err error) { 344 size := m.Size() 345 dAtA = make([]byte, size) 346 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 347 if err != nil { 348 return nil, err 349 } 350 return dAtA[:n], nil 351 } 352 353 func (m *NetAddress) MarshalTo(dAtA []byte) (int, error) { 354 size := m.Size() 355 return m.MarshalToSizedBuffer(dAtA[:size]) 356 } 357 358 func (m *NetAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) { 359 i := len(dAtA) 360 _ = i 361 var l int 362 _ = l 363 if m.Port != 0 { 364 i = encodeVarintTypes(dAtA, i, uint64(m.Port)) 365 i-- 366 dAtA[i] = 0x18 367 } 368 if len(m.IP) > 0 { 369 i -= len(m.IP) 370 copy(dAtA[i:], m.IP) 371 i = encodeVarintTypes(dAtA, i, uint64(len(m.IP))) 372 i-- 373 dAtA[i] = 0x12 374 } 375 if len(m.ID) > 0 { 376 i -= len(m.ID) 377 copy(dAtA[i:], m.ID) 378 i = encodeVarintTypes(dAtA, i, uint64(len(m.ID))) 379 i-- 380 dAtA[i] = 0xa 381 } 382 return len(dAtA) - i, nil 383 } 384 385 func (m *ProtocolVersion) Marshal() (dAtA []byte, err error) { 386 size := m.Size() 387 dAtA = make([]byte, size) 388 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 389 if err != nil { 390 return nil, err 391 } 392 return dAtA[:n], nil 393 } 394 395 func (m *ProtocolVersion) MarshalTo(dAtA []byte) (int, error) { 396 size := m.Size() 397 return m.MarshalToSizedBuffer(dAtA[:size]) 398 } 399 400 func (m *ProtocolVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) { 401 i := len(dAtA) 402 _ = i 403 var l int 404 _ = l 405 if m.App != 0 { 406 i = encodeVarintTypes(dAtA, i, uint64(m.App)) 407 i-- 408 dAtA[i] = 0x18 409 } 410 if m.Block != 0 { 411 i = encodeVarintTypes(dAtA, i, uint64(m.Block)) 412 i-- 413 dAtA[i] = 0x10 414 } 415 if m.P2P != 0 { 416 i = encodeVarintTypes(dAtA, i, uint64(m.P2P)) 417 i-- 418 dAtA[i] = 0x8 419 } 420 return len(dAtA) - i, nil 421 } 422 423 func (m *DefaultNodeInfo) Marshal() (dAtA []byte, err error) { 424 size := m.Size() 425 dAtA = make([]byte, size) 426 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 427 if err != nil { 428 return nil, err 429 } 430 return dAtA[:n], nil 431 } 432 433 func (m *DefaultNodeInfo) MarshalTo(dAtA []byte) (int, error) { 434 size := m.Size() 435 return m.MarshalToSizedBuffer(dAtA[:size]) 436 } 437 438 func (m *DefaultNodeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 439 i := len(dAtA) 440 _ = i 441 var l int 442 _ = l 443 { 444 size, err := m.Other.MarshalToSizedBuffer(dAtA[:i]) 445 if err != nil { 446 return 0, err 447 } 448 i -= size 449 i = encodeVarintTypes(dAtA, i, uint64(size)) 450 } 451 i-- 452 dAtA[i] = 0x42 453 if len(m.Moniker) > 0 { 454 i -= len(m.Moniker) 455 copy(dAtA[i:], m.Moniker) 456 i = encodeVarintTypes(dAtA, i, uint64(len(m.Moniker))) 457 i-- 458 dAtA[i] = 0x3a 459 } 460 if len(m.Channels) > 0 { 461 i -= len(m.Channels) 462 copy(dAtA[i:], m.Channels) 463 i = encodeVarintTypes(dAtA, i, uint64(len(m.Channels))) 464 i-- 465 dAtA[i] = 0x32 466 } 467 if len(m.Version) > 0 { 468 i -= len(m.Version) 469 copy(dAtA[i:], m.Version) 470 i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) 471 i-- 472 dAtA[i] = 0x2a 473 } 474 if len(m.Network) > 0 { 475 i -= len(m.Network) 476 copy(dAtA[i:], m.Network) 477 i = encodeVarintTypes(dAtA, i, uint64(len(m.Network))) 478 i-- 479 dAtA[i] = 0x22 480 } 481 if len(m.ListenAddr) > 0 { 482 i -= len(m.ListenAddr) 483 copy(dAtA[i:], m.ListenAddr) 484 i = encodeVarintTypes(dAtA, i, uint64(len(m.ListenAddr))) 485 i-- 486 dAtA[i] = 0x1a 487 } 488 if len(m.DefaultNodeID) > 0 { 489 i -= len(m.DefaultNodeID) 490 copy(dAtA[i:], m.DefaultNodeID) 491 i = encodeVarintTypes(dAtA, i, uint64(len(m.DefaultNodeID))) 492 i-- 493 dAtA[i] = 0x12 494 } 495 { 496 size, err := m.ProtocolVersion.MarshalToSizedBuffer(dAtA[:i]) 497 if err != nil { 498 return 0, err 499 } 500 i -= size 501 i = encodeVarintTypes(dAtA, i, uint64(size)) 502 } 503 i-- 504 dAtA[i] = 0xa 505 return len(dAtA) - i, nil 506 } 507 508 func (m *DefaultNodeInfoOther) Marshal() (dAtA []byte, err error) { 509 size := m.Size() 510 dAtA = make([]byte, size) 511 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 512 if err != nil { 513 return nil, err 514 } 515 return dAtA[:n], nil 516 } 517 518 func (m *DefaultNodeInfoOther) MarshalTo(dAtA []byte) (int, error) { 519 size := m.Size() 520 return m.MarshalToSizedBuffer(dAtA[:size]) 521 } 522 523 func (m *DefaultNodeInfoOther) MarshalToSizedBuffer(dAtA []byte) (int, error) { 524 i := len(dAtA) 525 _ = i 526 var l int 527 _ = l 528 if len(m.RPCAddress) > 0 { 529 i -= len(m.RPCAddress) 530 copy(dAtA[i:], m.RPCAddress) 531 i = encodeVarintTypes(dAtA, i, uint64(len(m.RPCAddress))) 532 i-- 533 dAtA[i] = 0x12 534 } 535 if len(m.TxIndex) > 0 { 536 i -= len(m.TxIndex) 537 copy(dAtA[i:], m.TxIndex) 538 i = encodeVarintTypes(dAtA, i, uint64(len(m.TxIndex))) 539 i-- 540 dAtA[i] = 0xa 541 } 542 return len(dAtA) - i, nil 543 } 544 545 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 546 offset -= sovTypes(v) 547 base := offset 548 for v >= 1<<7 { 549 dAtA[offset] = uint8(v&0x7f | 0x80) 550 v >>= 7 551 offset++ 552 } 553 dAtA[offset] = uint8(v) 554 return base 555 } 556 func (m *NetAddress) Size() (n int) { 557 if m == nil { 558 return 0 559 } 560 var l int 561 _ = l 562 l = len(m.ID) 563 if l > 0 { 564 n += 1 + l + sovTypes(uint64(l)) 565 } 566 l = len(m.IP) 567 if l > 0 { 568 n += 1 + l + sovTypes(uint64(l)) 569 } 570 if m.Port != 0 { 571 n += 1 + sovTypes(uint64(m.Port)) 572 } 573 return n 574 } 575 576 func (m *ProtocolVersion) Size() (n int) { 577 if m == nil { 578 return 0 579 } 580 var l int 581 _ = l 582 if m.P2P != 0 { 583 n += 1 + sovTypes(uint64(m.P2P)) 584 } 585 if m.Block != 0 { 586 n += 1 + sovTypes(uint64(m.Block)) 587 } 588 if m.App != 0 { 589 n += 1 + sovTypes(uint64(m.App)) 590 } 591 return n 592 } 593 594 func (m *DefaultNodeInfo) Size() (n int) { 595 if m == nil { 596 return 0 597 } 598 var l int 599 _ = l 600 l = m.ProtocolVersion.Size() 601 n += 1 + l + sovTypes(uint64(l)) 602 l = len(m.DefaultNodeID) 603 if l > 0 { 604 n += 1 + l + sovTypes(uint64(l)) 605 } 606 l = len(m.ListenAddr) 607 if l > 0 { 608 n += 1 + l + sovTypes(uint64(l)) 609 } 610 l = len(m.Network) 611 if l > 0 { 612 n += 1 + l + sovTypes(uint64(l)) 613 } 614 l = len(m.Version) 615 if l > 0 { 616 n += 1 + l + sovTypes(uint64(l)) 617 } 618 l = len(m.Channels) 619 if l > 0 { 620 n += 1 + l + sovTypes(uint64(l)) 621 } 622 l = len(m.Moniker) 623 if l > 0 { 624 n += 1 + l + sovTypes(uint64(l)) 625 } 626 l = m.Other.Size() 627 n += 1 + l + sovTypes(uint64(l)) 628 return n 629 } 630 631 func (m *DefaultNodeInfoOther) Size() (n int) { 632 if m == nil { 633 return 0 634 } 635 var l int 636 _ = l 637 l = len(m.TxIndex) 638 if l > 0 { 639 n += 1 + l + sovTypes(uint64(l)) 640 } 641 l = len(m.RPCAddress) 642 if l > 0 { 643 n += 1 + l + sovTypes(uint64(l)) 644 } 645 return n 646 } 647 648 func sovTypes(x uint64) (n int) { 649 return (math_bits.Len64(x|1) + 6) / 7 650 } 651 func sozTypes(x uint64) (n int) { 652 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 653 } 654 func (m *NetAddress) Unmarshal(dAtA []byte) error { 655 l := len(dAtA) 656 iNdEx := 0 657 for iNdEx < l { 658 preIndex := iNdEx 659 var wire uint64 660 for shift := uint(0); ; shift += 7 { 661 if shift >= 64 { 662 return ErrIntOverflowTypes 663 } 664 if iNdEx >= l { 665 return io.ErrUnexpectedEOF 666 } 667 b := dAtA[iNdEx] 668 iNdEx++ 669 wire |= uint64(b&0x7F) << shift 670 if b < 0x80 { 671 break 672 } 673 } 674 fieldNum := int32(wire >> 3) 675 wireType := int(wire & 0x7) 676 if wireType == 4 { 677 return fmt.Errorf("proto: NetAddress: wiretype end group for non-group") 678 } 679 if fieldNum <= 0 { 680 return fmt.Errorf("proto: NetAddress: illegal tag %d (wire type %d)", fieldNum, wire) 681 } 682 switch fieldNum { 683 case 1: 684 if wireType != 2 { 685 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 686 } 687 var stringLen uint64 688 for shift := uint(0); ; shift += 7 { 689 if shift >= 64 { 690 return ErrIntOverflowTypes 691 } 692 if iNdEx >= l { 693 return io.ErrUnexpectedEOF 694 } 695 b := dAtA[iNdEx] 696 iNdEx++ 697 stringLen |= uint64(b&0x7F) << shift 698 if b < 0x80 { 699 break 700 } 701 } 702 intStringLen := int(stringLen) 703 if intStringLen < 0 { 704 return ErrInvalidLengthTypes 705 } 706 postIndex := iNdEx + intStringLen 707 if postIndex < 0 { 708 return ErrInvalidLengthTypes 709 } 710 if postIndex > l { 711 return io.ErrUnexpectedEOF 712 } 713 m.ID = string(dAtA[iNdEx:postIndex]) 714 iNdEx = postIndex 715 case 2: 716 if wireType != 2 { 717 return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType) 718 } 719 var stringLen uint64 720 for shift := uint(0); ; shift += 7 { 721 if shift >= 64 { 722 return ErrIntOverflowTypes 723 } 724 if iNdEx >= l { 725 return io.ErrUnexpectedEOF 726 } 727 b := dAtA[iNdEx] 728 iNdEx++ 729 stringLen |= uint64(b&0x7F) << shift 730 if b < 0x80 { 731 break 732 } 733 } 734 intStringLen := int(stringLen) 735 if intStringLen < 0 { 736 return ErrInvalidLengthTypes 737 } 738 postIndex := iNdEx + intStringLen 739 if postIndex < 0 { 740 return ErrInvalidLengthTypes 741 } 742 if postIndex > l { 743 return io.ErrUnexpectedEOF 744 } 745 m.IP = string(dAtA[iNdEx:postIndex]) 746 iNdEx = postIndex 747 case 3: 748 if wireType != 0 { 749 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) 750 } 751 m.Port = 0 752 for shift := uint(0); ; shift += 7 { 753 if shift >= 64 { 754 return ErrIntOverflowTypes 755 } 756 if iNdEx >= l { 757 return io.ErrUnexpectedEOF 758 } 759 b := dAtA[iNdEx] 760 iNdEx++ 761 m.Port |= uint32(b&0x7F) << shift 762 if b < 0x80 { 763 break 764 } 765 } 766 default: 767 iNdEx = preIndex 768 skippy, err := skipTypes(dAtA[iNdEx:]) 769 if err != nil { 770 return err 771 } 772 if (skippy < 0) || (iNdEx+skippy) < 0 { 773 return ErrInvalidLengthTypes 774 } 775 if (iNdEx + skippy) > l { 776 return io.ErrUnexpectedEOF 777 } 778 iNdEx += skippy 779 } 780 } 781 782 if iNdEx > l { 783 return io.ErrUnexpectedEOF 784 } 785 return nil 786 } 787 func (m *ProtocolVersion) Unmarshal(dAtA []byte) error { 788 l := len(dAtA) 789 iNdEx := 0 790 for iNdEx < l { 791 preIndex := iNdEx 792 var wire uint64 793 for shift := uint(0); ; shift += 7 { 794 if shift >= 64 { 795 return ErrIntOverflowTypes 796 } 797 if iNdEx >= l { 798 return io.ErrUnexpectedEOF 799 } 800 b := dAtA[iNdEx] 801 iNdEx++ 802 wire |= uint64(b&0x7F) << shift 803 if b < 0x80 { 804 break 805 } 806 } 807 fieldNum := int32(wire >> 3) 808 wireType := int(wire & 0x7) 809 if wireType == 4 { 810 return fmt.Errorf("proto: ProtocolVersion: wiretype end group for non-group") 811 } 812 if fieldNum <= 0 { 813 return fmt.Errorf("proto: ProtocolVersion: illegal tag %d (wire type %d)", fieldNum, wire) 814 } 815 switch fieldNum { 816 case 1: 817 if wireType != 0 { 818 return fmt.Errorf("proto: wrong wireType = %d for field P2P", wireType) 819 } 820 m.P2P = 0 821 for shift := uint(0); ; shift += 7 { 822 if shift >= 64 { 823 return ErrIntOverflowTypes 824 } 825 if iNdEx >= l { 826 return io.ErrUnexpectedEOF 827 } 828 b := dAtA[iNdEx] 829 iNdEx++ 830 m.P2P |= uint64(b&0x7F) << shift 831 if b < 0x80 { 832 break 833 } 834 } 835 case 2: 836 if wireType != 0 { 837 return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) 838 } 839 m.Block = 0 840 for shift := uint(0); ; shift += 7 { 841 if shift >= 64 { 842 return ErrIntOverflowTypes 843 } 844 if iNdEx >= l { 845 return io.ErrUnexpectedEOF 846 } 847 b := dAtA[iNdEx] 848 iNdEx++ 849 m.Block |= uint64(b&0x7F) << shift 850 if b < 0x80 { 851 break 852 } 853 } 854 case 3: 855 if wireType != 0 { 856 return fmt.Errorf("proto: wrong wireType = %d for field App", wireType) 857 } 858 m.App = 0 859 for shift := uint(0); ; shift += 7 { 860 if shift >= 64 { 861 return ErrIntOverflowTypes 862 } 863 if iNdEx >= l { 864 return io.ErrUnexpectedEOF 865 } 866 b := dAtA[iNdEx] 867 iNdEx++ 868 m.App |= uint64(b&0x7F) << shift 869 if b < 0x80 { 870 break 871 } 872 } 873 default: 874 iNdEx = preIndex 875 skippy, err := skipTypes(dAtA[iNdEx:]) 876 if err != nil { 877 return err 878 } 879 if (skippy < 0) || (iNdEx+skippy) < 0 { 880 return ErrInvalidLengthTypes 881 } 882 if (iNdEx + skippy) > l { 883 return io.ErrUnexpectedEOF 884 } 885 iNdEx += skippy 886 } 887 } 888 889 if iNdEx > l { 890 return io.ErrUnexpectedEOF 891 } 892 return nil 893 } 894 func (m *DefaultNodeInfo) Unmarshal(dAtA []byte) error { 895 l := len(dAtA) 896 iNdEx := 0 897 for iNdEx < l { 898 preIndex := iNdEx 899 var wire uint64 900 for shift := uint(0); ; shift += 7 { 901 if shift >= 64 { 902 return ErrIntOverflowTypes 903 } 904 if iNdEx >= l { 905 return io.ErrUnexpectedEOF 906 } 907 b := dAtA[iNdEx] 908 iNdEx++ 909 wire |= uint64(b&0x7F) << shift 910 if b < 0x80 { 911 break 912 } 913 } 914 fieldNum := int32(wire >> 3) 915 wireType := int(wire & 0x7) 916 if wireType == 4 { 917 return fmt.Errorf("proto: DefaultNodeInfo: wiretype end group for non-group") 918 } 919 if fieldNum <= 0 { 920 return fmt.Errorf("proto: DefaultNodeInfo: illegal tag %d (wire type %d)", fieldNum, wire) 921 } 922 switch fieldNum { 923 case 1: 924 if wireType != 2 { 925 return fmt.Errorf("proto: wrong wireType = %d for field ProtocolVersion", wireType) 926 } 927 var msglen int 928 for shift := uint(0); ; shift += 7 { 929 if shift >= 64 { 930 return ErrIntOverflowTypes 931 } 932 if iNdEx >= l { 933 return io.ErrUnexpectedEOF 934 } 935 b := dAtA[iNdEx] 936 iNdEx++ 937 msglen |= int(b&0x7F) << shift 938 if b < 0x80 { 939 break 940 } 941 } 942 if msglen < 0 { 943 return ErrInvalidLengthTypes 944 } 945 postIndex := iNdEx + msglen 946 if postIndex < 0 { 947 return ErrInvalidLengthTypes 948 } 949 if postIndex > l { 950 return io.ErrUnexpectedEOF 951 } 952 if err := m.ProtocolVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 953 return err 954 } 955 iNdEx = postIndex 956 case 2: 957 if wireType != 2 { 958 return fmt.Errorf("proto: wrong wireType = %d for field DefaultNodeID", wireType) 959 } 960 var stringLen uint64 961 for shift := uint(0); ; shift += 7 { 962 if shift >= 64 { 963 return ErrIntOverflowTypes 964 } 965 if iNdEx >= l { 966 return io.ErrUnexpectedEOF 967 } 968 b := dAtA[iNdEx] 969 iNdEx++ 970 stringLen |= uint64(b&0x7F) << shift 971 if b < 0x80 { 972 break 973 } 974 } 975 intStringLen := int(stringLen) 976 if intStringLen < 0 { 977 return ErrInvalidLengthTypes 978 } 979 postIndex := iNdEx + intStringLen 980 if postIndex < 0 { 981 return ErrInvalidLengthTypes 982 } 983 if postIndex > l { 984 return io.ErrUnexpectedEOF 985 } 986 m.DefaultNodeID = string(dAtA[iNdEx:postIndex]) 987 iNdEx = postIndex 988 case 3: 989 if wireType != 2 { 990 return fmt.Errorf("proto: wrong wireType = %d for field ListenAddr", wireType) 991 } 992 var stringLen uint64 993 for shift := uint(0); ; shift += 7 { 994 if shift >= 64 { 995 return ErrIntOverflowTypes 996 } 997 if iNdEx >= l { 998 return io.ErrUnexpectedEOF 999 } 1000 b := dAtA[iNdEx] 1001 iNdEx++ 1002 stringLen |= uint64(b&0x7F) << shift 1003 if b < 0x80 { 1004 break 1005 } 1006 } 1007 intStringLen := int(stringLen) 1008 if intStringLen < 0 { 1009 return ErrInvalidLengthTypes 1010 } 1011 postIndex := iNdEx + intStringLen 1012 if postIndex < 0 { 1013 return ErrInvalidLengthTypes 1014 } 1015 if postIndex > l { 1016 return io.ErrUnexpectedEOF 1017 } 1018 m.ListenAddr = string(dAtA[iNdEx:postIndex]) 1019 iNdEx = postIndex 1020 case 4: 1021 if wireType != 2 { 1022 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) 1023 } 1024 var stringLen uint64 1025 for shift := uint(0); ; shift += 7 { 1026 if shift >= 64 { 1027 return ErrIntOverflowTypes 1028 } 1029 if iNdEx >= l { 1030 return io.ErrUnexpectedEOF 1031 } 1032 b := dAtA[iNdEx] 1033 iNdEx++ 1034 stringLen |= uint64(b&0x7F) << shift 1035 if b < 0x80 { 1036 break 1037 } 1038 } 1039 intStringLen := int(stringLen) 1040 if intStringLen < 0 { 1041 return ErrInvalidLengthTypes 1042 } 1043 postIndex := iNdEx + intStringLen 1044 if postIndex < 0 { 1045 return ErrInvalidLengthTypes 1046 } 1047 if postIndex > l { 1048 return io.ErrUnexpectedEOF 1049 } 1050 m.Network = string(dAtA[iNdEx:postIndex]) 1051 iNdEx = postIndex 1052 case 5: 1053 if wireType != 2 { 1054 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 1055 } 1056 var stringLen uint64 1057 for shift := uint(0); ; shift += 7 { 1058 if shift >= 64 { 1059 return ErrIntOverflowTypes 1060 } 1061 if iNdEx >= l { 1062 return io.ErrUnexpectedEOF 1063 } 1064 b := dAtA[iNdEx] 1065 iNdEx++ 1066 stringLen |= uint64(b&0x7F) << shift 1067 if b < 0x80 { 1068 break 1069 } 1070 } 1071 intStringLen := int(stringLen) 1072 if intStringLen < 0 { 1073 return ErrInvalidLengthTypes 1074 } 1075 postIndex := iNdEx + intStringLen 1076 if postIndex < 0 { 1077 return ErrInvalidLengthTypes 1078 } 1079 if postIndex > l { 1080 return io.ErrUnexpectedEOF 1081 } 1082 m.Version = string(dAtA[iNdEx:postIndex]) 1083 iNdEx = postIndex 1084 case 6: 1085 if wireType != 2 { 1086 return fmt.Errorf("proto: wrong wireType = %d for field Channels", wireType) 1087 } 1088 var byteLen int 1089 for shift := uint(0); ; shift += 7 { 1090 if shift >= 64 { 1091 return ErrIntOverflowTypes 1092 } 1093 if iNdEx >= l { 1094 return io.ErrUnexpectedEOF 1095 } 1096 b := dAtA[iNdEx] 1097 iNdEx++ 1098 byteLen |= int(b&0x7F) << shift 1099 if b < 0x80 { 1100 break 1101 } 1102 } 1103 if byteLen < 0 { 1104 return ErrInvalidLengthTypes 1105 } 1106 postIndex := iNdEx + byteLen 1107 if postIndex < 0 { 1108 return ErrInvalidLengthTypes 1109 } 1110 if postIndex > l { 1111 return io.ErrUnexpectedEOF 1112 } 1113 m.Channels = append(m.Channels[:0], dAtA[iNdEx:postIndex]...) 1114 if m.Channels == nil { 1115 m.Channels = []byte{} 1116 } 1117 iNdEx = postIndex 1118 case 7: 1119 if wireType != 2 { 1120 return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType) 1121 } 1122 var stringLen uint64 1123 for shift := uint(0); ; shift += 7 { 1124 if shift >= 64 { 1125 return ErrIntOverflowTypes 1126 } 1127 if iNdEx >= l { 1128 return io.ErrUnexpectedEOF 1129 } 1130 b := dAtA[iNdEx] 1131 iNdEx++ 1132 stringLen |= uint64(b&0x7F) << shift 1133 if b < 0x80 { 1134 break 1135 } 1136 } 1137 intStringLen := int(stringLen) 1138 if intStringLen < 0 { 1139 return ErrInvalidLengthTypes 1140 } 1141 postIndex := iNdEx + intStringLen 1142 if postIndex < 0 { 1143 return ErrInvalidLengthTypes 1144 } 1145 if postIndex > l { 1146 return io.ErrUnexpectedEOF 1147 } 1148 m.Moniker = string(dAtA[iNdEx:postIndex]) 1149 iNdEx = postIndex 1150 case 8: 1151 if wireType != 2 { 1152 return fmt.Errorf("proto: wrong wireType = %d for field Other", wireType) 1153 } 1154 var msglen int 1155 for shift := uint(0); ; shift += 7 { 1156 if shift >= 64 { 1157 return ErrIntOverflowTypes 1158 } 1159 if iNdEx >= l { 1160 return io.ErrUnexpectedEOF 1161 } 1162 b := dAtA[iNdEx] 1163 iNdEx++ 1164 msglen |= int(b&0x7F) << shift 1165 if b < 0x80 { 1166 break 1167 } 1168 } 1169 if msglen < 0 { 1170 return ErrInvalidLengthTypes 1171 } 1172 postIndex := iNdEx + msglen 1173 if postIndex < 0 { 1174 return ErrInvalidLengthTypes 1175 } 1176 if postIndex > l { 1177 return io.ErrUnexpectedEOF 1178 } 1179 if err := m.Other.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1180 return err 1181 } 1182 iNdEx = postIndex 1183 default: 1184 iNdEx = preIndex 1185 skippy, err := skipTypes(dAtA[iNdEx:]) 1186 if err != nil { 1187 return err 1188 } 1189 if (skippy < 0) || (iNdEx+skippy) < 0 { 1190 return ErrInvalidLengthTypes 1191 } 1192 if (iNdEx + skippy) > l { 1193 return io.ErrUnexpectedEOF 1194 } 1195 iNdEx += skippy 1196 } 1197 } 1198 1199 if iNdEx > l { 1200 return io.ErrUnexpectedEOF 1201 } 1202 return nil 1203 } 1204 func (m *DefaultNodeInfoOther) Unmarshal(dAtA []byte) error { 1205 l := len(dAtA) 1206 iNdEx := 0 1207 for iNdEx < l { 1208 preIndex := iNdEx 1209 var wire uint64 1210 for shift := uint(0); ; shift += 7 { 1211 if shift >= 64 { 1212 return ErrIntOverflowTypes 1213 } 1214 if iNdEx >= l { 1215 return io.ErrUnexpectedEOF 1216 } 1217 b := dAtA[iNdEx] 1218 iNdEx++ 1219 wire |= uint64(b&0x7F) << shift 1220 if b < 0x80 { 1221 break 1222 } 1223 } 1224 fieldNum := int32(wire >> 3) 1225 wireType := int(wire & 0x7) 1226 if wireType == 4 { 1227 return fmt.Errorf("proto: DefaultNodeInfoOther: wiretype end group for non-group") 1228 } 1229 if fieldNum <= 0 { 1230 return fmt.Errorf("proto: DefaultNodeInfoOther: illegal tag %d (wire type %d)", fieldNum, wire) 1231 } 1232 switch fieldNum { 1233 case 1: 1234 if wireType != 2 { 1235 return fmt.Errorf("proto: wrong wireType = %d for field TxIndex", wireType) 1236 } 1237 var stringLen uint64 1238 for shift := uint(0); ; shift += 7 { 1239 if shift >= 64 { 1240 return ErrIntOverflowTypes 1241 } 1242 if iNdEx >= l { 1243 return io.ErrUnexpectedEOF 1244 } 1245 b := dAtA[iNdEx] 1246 iNdEx++ 1247 stringLen |= uint64(b&0x7F) << shift 1248 if b < 0x80 { 1249 break 1250 } 1251 } 1252 intStringLen := int(stringLen) 1253 if intStringLen < 0 { 1254 return ErrInvalidLengthTypes 1255 } 1256 postIndex := iNdEx + intStringLen 1257 if postIndex < 0 { 1258 return ErrInvalidLengthTypes 1259 } 1260 if postIndex > l { 1261 return io.ErrUnexpectedEOF 1262 } 1263 m.TxIndex = string(dAtA[iNdEx:postIndex]) 1264 iNdEx = postIndex 1265 case 2: 1266 if wireType != 2 { 1267 return fmt.Errorf("proto: wrong wireType = %d for field RPCAddress", wireType) 1268 } 1269 var stringLen uint64 1270 for shift := uint(0); ; shift += 7 { 1271 if shift >= 64 { 1272 return ErrIntOverflowTypes 1273 } 1274 if iNdEx >= l { 1275 return io.ErrUnexpectedEOF 1276 } 1277 b := dAtA[iNdEx] 1278 iNdEx++ 1279 stringLen |= uint64(b&0x7F) << shift 1280 if b < 0x80 { 1281 break 1282 } 1283 } 1284 intStringLen := int(stringLen) 1285 if intStringLen < 0 { 1286 return ErrInvalidLengthTypes 1287 } 1288 postIndex := iNdEx + intStringLen 1289 if postIndex < 0 { 1290 return ErrInvalidLengthTypes 1291 } 1292 if postIndex > l { 1293 return io.ErrUnexpectedEOF 1294 } 1295 m.RPCAddress = string(dAtA[iNdEx:postIndex]) 1296 iNdEx = postIndex 1297 default: 1298 iNdEx = preIndex 1299 skippy, err := skipTypes(dAtA[iNdEx:]) 1300 if err != nil { 1301 return err 1302 } 1303 if (skippy < 0) || (iNdEx+skippy) < 0 { 1304 return ErrInvalidLengthTypes 1305 } 1306 if (iNdEx + skippy) > l { 1307 return io.ErrUnexpectedEOF 1308 } 1309 iNdEx += skippy 1310 } 1311 } 1312 1313 if iNdEx > l { 1314 return io.ErrUnexpectedEOF 1315 } 1316 return nil 1317 } 1318 func skipTypes(dAtA []byte) (n int, err error) { 1319 l := len(dAtA) 1320 iNdEx := 0 1321 depth := 0 1322 for iNdEx < l { 1323 var wire uint64 1324 for shift := uint(0); ; shift += 7 { 1325 if shift >= 64 { 1326 return 0, ErrIntOverflowTypes 1327 } 1328 if iNdEx >= l { 1329 return 0, io.ErrUnexpectedEOF 1330 } 1331 b := dAtA[iNdEx] 1332 iNdEx++ 1333 wire |= (uint64(b) & 0x7F) << shift 1334 if b < 0x80 { 1335 break 1336 } 1337 } 1338 wireType := int(wire & 0x7) 1339 switch wireType { 1340 case 0: 1341 for shift := uint(0); ; shift += 7 { 1342 if shift >= 64 { 1343 return 0, ErrIntOverflowTypes 1344 } 1345 if iNdEx >= l { 1346 return 0, io.ErrUnexpectedEOF 1347 } 1348 iNdEx++ 1349 if dAtA[iNdEx-1] < 0x80 { 1350 break 1351 } 1352 } 1353 case 1: 1354 iNdEx += 8 1355 case 2: 1356 var length int 1357 for shift := uint(0); ; shift += 7 { 1358 if shift >= 64 { 1359 return 0, ErrIntOverflowTypes 1360 } 1361 if iNdEx >= l { 1362 return 0, io.ErrUnexpectedEOF 1363 } 1364 b := dAtA[iNdEx] 1365 iNdEx++ 1366 length |= (int(b) & 0x7F) << shift 1367 if b < 0x80 { 1368 break 1369 } 1370 } 1371 if length < 0 { 1372 return 0, ErrInvalidLengthTypes 1373 } 1374 iNdEx += length 1375 case 3: 1376 depth++ 1377 case 4: 1378 if depth == 0 { 1379 return 0, ErrUnexpectedEndOfGroupTypes 1380 } 1381 depth-- 1382 case 5: 1383 iNdEx += 4 1384 default: 1385 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1386 } 1387 if iNdEx < 0 { 1388 return 0, ErrInvalidLengthTypes 1389 } 1390 if depth == 0 { 1391 return iNdEx, nil 1392 } 1393 } 1394 return 0, io.ErrUnexpectedEOF 1395 } 1396 1397 var ( 1398 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 1399 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 1400 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 1401 )