github.com/Tri-stone/burrow@v0.25.0/txs/txs.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: txs.proto 3 4 package txs 5 6 import ( 7 fmt "fmt" 8 io "io" 9 math "math" 10 11 _ "github.com/gogo/protobuf/gogoproto" 12 proto "github.com/gogo/protobuf/proto" 13 golang_proto "github.com/golang/protobuf/proto" 14 github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary" 15 crypto "github.com/hyperledger/burrow/crypto" 16 github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto" 17 github_com_hyperledger_burrow_txs_payload "github.com/hyperledger/burrow/txs/payload" 18 ) 19 20 // Reference imports to suppress errors if they are not otherwise used. 21 var _ = proto.Marshal 22 var _ = golang_proto.Marshal 23 var _ = fmt.Errorf 24 var _ = math.Inf 25 26 // This is a compile-time assertion to ensure that this generated file 27 // is compatible with the proto package it is being compiled against. 28 // A compilation error at this line likely means your copy of the 29 // proto package needs to be updated. 30 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 31 32 // An envelope contains both the signable Tx and the signatures for each input (in signatories) 33 type Envelope struct { 34 Signatories []Signatory `protobuf:"bytes,1,rep,name=Signatories,proto3" json:"Signatories"` 35 // Canonical bytes of the Tx ready to be signed 36 Tx *Tx `protobuf:"bytes,2,opt,name=Tx,proto3,customtype=Tx" json:"Tx,omitempty"` 37 XXX_NoUnkeyedLiteral struct{} `json:"-"` 38 XXX_unrecognized []byte `json:"-"` 39 XXX_sizecache int32 `json:"-"` 40 } 41 42 func (m *Envelope) Reset() { *m = Envelope{} } 43 func (*Envelope) ProtoMessage() {} 44 func (*Envelope) Descriptor() ([]byte, []int) { 45 return fileDescriptor_372ebcf753025bdc, []int{0} 46 } 47 func (m *Envelope) XXX_Unmarshal(b []byte) error { 48 return m.Unmarshal(b) 49 } 50 func (m *Envelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 51 if deterministic { 52 return xxx_messageInfo_Envelope.Marshal(b, m, deterministic) 53 } else { 54 b = b[:cap(b)] 55 n, err := m.MarshalTo(b) 56 if err != nil { 57 return nil, err 58 } 59 return b[:n], nil 60 } 61 } 62 func (m *Envelope) XXX_Merge(src proto.Message) { 63 xxx_messageInfo_Envelope.Merge(m, src) 64 } 65 func (m *Envelope) XXX_Size() int { 66 return m.Size() 67 } 68 func (m *Envelope) XXX_DiscardUnknown() { 69 xxx_messageInfo_Envelope.DiscardUnknown(m) 70 } 71 72 var xxx_messageInfo_Envelope proto.InternalMessageInfo 73 74 func (m *Envelope) GetSignatories() []Signatory { 75 if m != nil { 76 return m.Signatories 77 } 78 return nil 79 } 80 81 func (*Envelope) XXX_MessageName() string { 82 return "txs.Envelope" 83 } 84 85 // Signatory contains signature and one or both of Address and PublicKey to identify the signer 86 type Signatory struct { 87 Address *github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address,omitempty"` 88 PublicKey *crypto.PublicKey `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"` 89 Signature *crypto.Signature `protobuf:"bytes,4,opt,name=Signature,proto3" json:"Signature,omitempty"` 90 XXX_NoUnkeyedLiteral struct{} `json:"-"` 91 XXX_unrecognized []byte `json:"-"` 92 XXX_sizecache int32 `json:"-"` 93 } 94 95 func (m *Signatory) Reset() { *m = Signatory{} } 96 func (m *Signatory) String() string { return proto.CompactTextString(m) } 97 func (*Signatory) ProtoMessage() {} 98 func (*Signatory) Descriptor() ([]byte, []int) { 99 return fileDescriptor_372ebcf753025bdc, []int{1} 100 } 101 func (m *Signatory) XXX_Unmarshal(b []byte) error { 102 return m.Unmarshal(b) 103 } 104 func (m *Signatory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 105 if deterministic { 106 return xxx_messageInfo_Signatory.Marshal(b, m, deterministic) 107 } else { 108 b = b[:cap(b)] 109 n, err := m.MarshalTo(b) 110 if err != nil { 111 return nil, err 112 } 113 return b[:n], nil 114 } 115 } 116 func (m *Signatory) XXX_Merge(src proto.Message) { 117 xxx_messageInfo_Signatory.Merge(m, src) 118 } 119 func (m *Signatory) XXX_Size() int { 120 return m.Size() 121 } 122 func (m *Signatory) XXX_DiscardUnknown() { 123 xxx_messageInfo_Signatory.DiscardUnknown(m) 124 } 125 126 var xxx_messageInfo_Signatory proto.InternalMessageInfo 127 128 func (m *Signatory) GetPublicKey() *crypto.PublicKey { 129 if m != nil { 130 return m.PublicKey 131 } 132 return nil 133 } 134 135 func (m *Signatory) GetSignature() *crypto.Signature { 136 if m != nil { 137 return m.Signature 138 } 139 return nil 140 } 141 142 func (*Signatory) XXX_MessageName() string { 143 return "txs.Signatory" 144 } 145 146 // BroadcastTx or Transaction receipt 147 type Receipt struct { 148 // Transaction type 149 TxType github_com_hyperledger_burrow_txs_payload.Type `protobuf:"varint,1,opt,name=TxType,proto3,casttype=github.com/hyperledger/burrow/txs/payload.Type" json:"TxType,omitempty"` 150 // The hash of the transaction that caused this event to be generated 151 TxHash github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,2,opt,name=TxHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"TxHash"` 152 // Whether the transaction creates a contract 153 CreatesContract bool `protobuf:"varint,3,opt,name=CreatesContract,proto3" json:"CreatesContract,omitempty"` 154 // The address of the contract being called 155 ContractAddress github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,4,opt,name=ContractAddress,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"ContractAddress"` 156 XXX_NoUnkeyedLiteral struct{} `json:"-"` 157 XXX_unrecognized []byte `json:"-"` 158 XXX_sizecache int32 `json:"-"` 159 } 160 161 func (m *Receipt) Reset() { *m = Receipt{} } 162 func (m *Receipt) String() string { return proto.CompactTextString(m) } 163 func (*Receipt) ProtoMessage() {} 164 func (*Receipt) Descriptor() ([]byte, []int) { 165 return fileDescriptor_372ebcf753025bdc, []int{2} 166 } 167 func (m *Receipt) XXX_Unmarshal(b []byte) error { 168 return m.Unmarshal(b) 169 } 170 func (m *Receipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 171 if deterministic { 172 return xxx_messageInfo_Receipt.Marshal(b, m, deterministic) 173 } else { 174 b = b[:cap(b)] 175 n, err := m.MarshalTo(b) 176 if err != nil { 177 return nil, err 178 } 179 return b[:n], nil 180 } 181 } 182 func (m *Receipt) XXX_Merge(src proto.Message) { 183 xxx_messageInfo_Receipt.Merge(m, src) 184 } 185 func (m *Receipt) XXX_Size() int { 186 return m.Size() 187 } 188 func (m *Receipt) XXX_DiscardUnknown() { 189 xxx_messageInfo_Receipt.DiscardUnknown(m) 190 } 191 192 var xxx_messageInfo_Receipt proto.InternalMessageInfo 193 194 func (m *Receipt) GetTxType() github_com_hyperledger_burrow_txs_payload.Type { 195 if m != nil { 196 return m.TxType 197 } 198 return 0 199 } 200 201 func (m *Receipt) GetCreatesContract() bool { 202 if m != nil { 203 return m.CreatesContract 204 } 205 return false 206 } 207 208 func (*Receipt) XXX_MessageName() string { 209 return "txs.Receipt" 210 } 211 func init() { 212 proto.RegisterType((*Envelope)(nil), "txs.Envelope") 213 golang_proto.RegisterType((*Envelope)(nil), "txs.Envelope") 214 proto.RegisterType((*Signatory)(nil), "txs.Signatory") 215 golang_proto.RegisterType((*Signatory)(nil), "txs.Signatory") 216 proto.RegisterType((*Receipt)(nil), "txs.Receipt") 217 golang_proto.RegisterType((*Receipt)(nil), "txs.Receipt") 218 } 219 220 func init() { proto.RegisterFile("txs.proto", fileDescriptor_372ebcf753025bdc) } 221 func init() { golang_proto.RegisterFile("txs.proto", fileDescriptor_372ebcf753025bdc) } 222 223 var fileDescriptor_372ebcf753025bdc = []byte{ 224 // 421 bytes of a gzipped FileDescriptorProto 225 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xbf, 0x6f, 0xd3, 0x40, 226 0x14, 0xee, 0x39, 0x51, 0xda, 0x5c, 0x0a, 0x15, 0x37, 0xa0, 0xa8, 0x83, 0x1d, 0x32, 0x65, 0xa0, 227 0x36, 0x0a, 0xbf, 0x24, 0x36, 0x5c, 0x21, 0x55, 0x45, 0x48, 0xe8, 0xf0, 0xc4, 0x80, 0xb0, 0x9d, 228 0x87, 0x63, 0xc9, 0xf8, 0xac, 0xbb, 0x33, 0xdc, 0xfd, 0x27, 0x8c, 0xfc, 0x05, 0xec, 0x6c, 0x8c, 229 0x19, 0x99, 0x33, 0x58, 0x28, 0xfd, 0x2f, 0x98, 0x90, 0xaf, 0xe7, 0xb4, 0x74, 0x08, 0x62, 0x7b, 230 0x3f, 0xbe, 0xef, 0x7b, 0xdf, 0xbd, 0x77, 0x78, 0x28, 0x95, 0xf0, 0x2b, 0xce, 0x24, 0x23, 0x3d, 231 0xa9, 0xc4, 0xf1, 0x49, 0x96, 0xcb, 0x65, 0x9d, 0xf8, 0x29, 0xfb, 0x18, 0x64, 0x2c, 0x63, 0x81, 232 0xe9, 0x25, 0xf5, 0x07, 0x93, 0x99, 0xc4, 0x44, 0x97, 0x9c, 0xe3, 0xc3, 0x94, 0xeb, 0x4a, 0xda, 233 0x6c, 0xfa, 0x1e, 0x1f, 0xbc, 0x28, 0x3f, 0x41, 0xc1, 0x2a, 0x20, 0x4f, 0xf0, 0xe8, 0x4d, 0x9e, 234 0x95, 0xb1, 0x64, 0x3c, 0x07, 0x31, 0x46, 0x93, 0xde, 0x6c, 0x34, 0xbf, 0xed, 0xb7, 0xe3, 0xba, 235 0xba, 0x0e, 0xfb, 0xab, 0xc6, 0xdb, 0xa3, 0xd7, 0x81, 0xe4, 0x2e, 0x76, 0x22, 0x35, 0x76, 0x26, 236 0x68, 0x76, 0x18, 0x0e, 0xd6, 0x8d, 0xe7, 0x44, 0x8a, 0x3a, 0x91, 0x7a, 0xd6, 0xff, 0xf2, 0xd5, 237 0xdb, 0x9b, 0x7e, 0x47, 0x78, 0xb8, 0xa5, 0x93, 0x73, 0xbc, 0xff, 0x7c, 0xb1, 0xe0, 0x20, 0x5a, 238 0xfd, 0x96, 0xf0, 0x60, 0xdd, 0x78, 0xf7, 0xaf, 0xbd, 0x60, 0xa9, 0x2b, 0xe0, 0x05, 0x2c, 0x32, 239 0xe0, 0x41, 0x52, 0x73, 0xce, 0x3e, 0x07, 0xd6, 0xb0, 0xe5, 0xd1, 0x4e, 0x80, 0x04, 0x78, 0xf8, 240 0xba, 0x4e, 0x8a, 0x3c, 0x7d, 0x09, 0xda, 0x8c, 0x1f, 0xcd, 0xef, 0xf8, 0x16, 0xbc, 0x6d, 0xd0, 241 0x2b, 0x4c, 0x4b, 0xb8, 0x74, 0x52, 0x73, 0x18, 0xf7, 0xff, 0x26, 0x6c, 0x1b, 0xf4, 0x0a, 0x33, 242 0xfd, 0xe6, 0xe0, 0x7d, 0x0a, 0x29, 0xe4, 0x95, 0x24, 0xe7, 0x78, 0x10, 0xa9, 0x48, 0x57, 0x60, 243 0x8c, 0xdf, 0x0a, 0xe7, 0xbf, 0x1b, 0xcf, 0xdf, 0x6d, 0x5c, 0x2a, 0x11, 0x54, 0xb1, 0x2e, 0x58, 244 0xbc, 0xf0, 0x5b, 0x26, 0xb5, 0x0a, 0xe4, 0x55, 0xab, 0x75, 0x16, 0x8b, 0xa5, 0xdd, 0xda, 0xe3, 245 0x76, 0xa9, 0xeb, 0xc6, 0x3b, 0xd9, 0xad, 0x97, 0xe4, 0x65, 0xcc, 0xb5, 0x7f, 0x06, 0x2a, 0xd4, 246 0x12, 0x04, 0xb5, 0x22, 0x64, 0x86, 0x8f, 0x4e, 0x39, 0xc4, 0x12, 0xc4, 0x29, 0x2b, 0x25, 0x8f, 247 0x53, 0x39, 0xee, 0x4d, 0xd0, 0xec, 0x80, 0xde, 0x2c, 0x93, 0x77, 0xf8, 0xa8, 0x8b, 0xbb, 0x33, 248 0xf4, 0x8d, 0x83, 0x47, 0xd6, 0xc1, 0xff, 0x9d, 0xe2, 0xa6, 0x58, 0xf8, 0x74, 0xb5, 0x71, 0xd1, 249 0xcf, 0x8d, 0x8b, 0x7e, 0x6d, 0x5c, 0xf4, 0xe3, 0xc2, 0x45, 0xab, 0x0b, 0x17, 0xbd, 0xbd, 0xf7, 250 0xcf, 0x35, 0x25, 0x03, 0xf3, 0x1d, 0x1f, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xe2, 0x91, 251 0x22, 0xdd, 0x02, 0x00, 0x00, 252 } 253 254 func (m *Envelope) Marshal() (dAtA []byte, err error) { 255 size := m.Size() 256 dAtA = make([]byte, size) 257 n, err := m.MarshalTo(dAtA) 258 if err != nil { 259 return nil, err 260 } 261 return dAtA[:n], nil 262 } 263 264 func (m *Envelope) MarshalTo(dAtA []byte) (int, error) { 265 var i int 266 _ = i 267 var l int 268 _ = l 269 if len(m.Signatories) > 0 { 270 for _, msg := range m.Signatories { 271 dAtA[i] = 0xa 272 i++ 273 i = encodeVarintTxs(dAtA, i, uint64(msg.Size())) 274 n, err := msg.MarshalTo(dAtA[i:]) 275 if err != nil { 276 return 0, err 277 } 278 i += n 279 } 280 } 281 if m.Tx != nil { 282 dAtA[i] = 0x12 283 i++ 284 i = encodeVarintTxs(dAtA, i, uint64(m.Tx.Size())) 285 n1, err := m.Tx.MarshalTo(dAtA[i:]) 286 if err != nil { 287 return 0, err 288 } 289 i += n1 290 } 291 if m.XXX_unrecognized != nil { 292 i += copy(dAtA[i:], m.XXX_unrecognized) 293 } 294 return i, nil 295 } 296 297 func (m *Signatory) Marshal() (dAtA []byte, err error) { 298 size := m.Size() 299 dAtA = make([]byte, size) 300 n, err := m.MarshalTo(dAtA) 301 if err != nil { 302 return nil, err 303 } 304 return dAtA[:n], nil 305 } 306 307 func (m *Signatory) MarshalTo(dAtA []byte) (int, error) { 308 var i int 309 _ = i 310 var l int 311 _ = l 312 if m.Address != nil { 313 dAtA[i] = 0xa 314 i++ 315 i = encodeVarintTxs(dAtA, i, uint64(m.Address.Size())) 316 n2, err := m.Address.MarshalTo(dAtA[i:]) 317 if err != nil { 318 return 0, err 319 } 320 i += n2 321 } 322 if m.PublicKey != nil { 323 dAtA[i] = 0x12 324 i++ 325 i = encodeVarintTxs(dAtA, i, uint64(m.PublicKey.Size())) 326 n3, err := m.PublicKey.MarshalTo(dAtA[i:]) 327 if err != nil { 328 return 0, err 329 } 330 i += n3 331 } 332 if m.Signature != nil { 333 dAtA[i] = 0x22 334 i++ 335 i = encodeVarintTxs(dAtA, i, uint64(m.Signature.Size())) 336 n4, err := m.Signature.MarshalTo(dAtA[i:]) 337 if err != nil { 338 return 0, err 339 } 340 i += n4 341 } 342 if m.XXX_unrecognized != nil { 343 i += copy(dAtA[i:], m.XXX_unrecognized) 344 } 345 return i, nil 346 } 347 348 func (m *Receipt) Marshal() (dAtA []byte, err error) { 349 size := m.Size() 350 dAtA = make([]byte, size) 351 n, err := m.MarshalTo(dAtA) 352 if err != nil { 353 return nil, err 354 } 355 return dAtA[:n], nil 356 } 357 358 func (m *Receipt) MarshalTo(dAtA []byte) (int, error) { 359 var i int 360 _ = i 361 var l int 362 _ = l 363 if m.TxType != 0 { 364 dAtA[i] = 0x8 365 i++ 366 i = encodeVarintTxs(dAtA, i, uint64(m.TxType)) 367 } 368 dAtA[i] = 0x12 369 i++ 370 i = encodeVarintTxs(dAtA, i, uint64(m.TxHash.Size())) 371 n5, err := m.TxHash.MarshalTo(dAtA[i:]) 372 if err != nil { 373 return 0, err 374 } 375 i += n5 376 if m.CreatesContract { 377 dAtA[i] = 0x18 378 i++ 379 if m.CreatesContract { 380 dAtA[i] = 1 381 } else { 382 dAtA[i] = 0 383 } 384 i++ 385 } 386 dAtA[i] = 0x22 387 i++ 388 i = encodeVarintTxs(dAtA, i, uint64(m.ContractAddress.Size())) 389 n6, err := m.ContractAddress.MarshalTo(dAtA[i:]) 390 if err != nil { 391 return 0, err 392 } 393 i += n6 394 if m.XXX_unrecognized != nil { 395 i += copy(dAtA[i:], m.XXX_unrecognized) 396 } 397 return i, nil 398 } 399 400 func encodeVarintTxs(dAtA []byte, offset int, v uint64) int { 401 for v >= 1<<7 { 402 dAtA[offset] = uint8(v&0x7f | 0x80) 403 v >>= 7 404 offset++ 405 } 406 dAtA[offset] = uint8(v) 407 return offset + 1 408 } 409 func (m *Envelope) Size() (n int) { 410 if m == nil { 411 return 0 412 } 413 var l int 414 _ = l 415 if len(m.Signatories) > 0 { 416 for _, e := range m.Signatories { 417 l = e.Size() 418 n += 1 + l + sovTxs(uint64(l)) 419 } 420 } 421 if m.Tx != nil { 422 l = m.Tx.Size() 423 n += 1 + l + sovTxs(uint64(l)) 424 } 425 if m.XXX_unrecognized != nil { 426 n += len(m.XXX_unrecognized) 427 } 428 return n 429 } 430 431 func (m *Signatory) Size() (n int) { 432 if m == nil { 433 return 0 434 } 435 var l int 436 _ = l 437 if m.Address != nil { 438 l = m.Address.Size() 439 n += 1 + l + sovTxs(uint64(l)) 440 } 441 if m.PublicKey != nil { 442 l = m.PublicKey.Size() 443 n += 1 + l + sovTxs(uint64(l)) 444 } 445 if m.Signature != nil { 446 l = m.Signature.Size() 447 n += 1 + l + sovTxs(uint64(l)) 448 } 449 if m.XXX_unrecognized != nil { 450 n += len(m.XXX_unrecognized) 451 } 452 return n 453 } 454 455 func (m *Receipt) Size() (n int) { 456 if m == nil { 457 return 0 458 } 459 var l int 460 _ = l 461 if m.TxType != 0 { 462 n += 1 + sovTxs(uint64(m.TxType)) 463 } 464 l = m.TxHash.Size() 465 n += 1 + l + sovTxs(uint64(l)) 466 if m.CreatesContract { 467 n += 2 468 } 469 l = m.ContractAddress.Size() 470 n += 1 + l + sovTxs(uint64(l)) 471 if m.XXX_unrecognized != nil { 472 n += len(m.XXX_unrecognized) 473 } 474 return n 475 } 476 477 func sovTxs(x uint64) (n int) { 478 for { 479 n++ 480 x >>= 7 481 if x == 0 { 482 break 483 } 484 } 485 return n 486 } 487 func sozTxs(x uint64) (n int) { 488 return sovTxs(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 489 } 490 func (m *Envelope) Unmarshal(dAtA []byte) error { 491 l := len(dAtA) 492 iNdEx := 0 493 for iNdEx < l { 494 preIndex := iNdEx 495 var wire uint64 496 for shift := uint(0); ; shift += 7 { 497 if shift >= 64 { 498 return ErrIntOverflowTxs 499 } 500 if iNdEx >= l { 501 return io.ErrUnexpectedEOF 502 } 503 b := dAtA[iNdEx] 504 iNdEx++ 505 wire |= uint64(b&0x7F) << shift 506 if b < 0x80 { 507 break 508 } 509 } 510 fieldNum := int32(wire >> 3) 511 wireType := int(wire & 0x7) 512 if wireType == 4 { 513 return fmt.Errorf("proto: Envelope: wiretype end group for non-group") 514 } 515 if fieldNum <= 0 { 516 return fmt.Errorf("proto: Envelope: illegal tag %d (wire type %d)", fieldNum, wire) 517 } 518 switch fieldNum { 519 case 1: 520 if wireType != 2 { 521 return fmt.Errorf("proto: wrong wireType = %d for field Signatories", wireType) 522 } 523 var msglen int 524 for shift := uint(0); ; shift += 7 { 525 if shift >= 64 { 526 return ErrIntOverflowTxs 527 } 528 if iNdEx >= l { 529 return io.ErrUnexpectedEOF 530 } 531 b := dAtA[iNdEx] 532 iNdEx++ 533 msglen |= int(b&0x7F) << shift 534 if b < 0x80 { 535 break 536 } 537 } 538 if msglen < 0 { 539 return ErrInvalidLengthTxs 540 } 541 postIndex := iNdEx + msglen 542 if postIndex < 0 { 543 return ErrInvalidLengthTxs 544 } 545 if postIndex > l { 546 return io.ErrUnexpectedEOF 547 } 548 m.Signatories = append(m.Signatories, Signatory{}) 549 if err := m.Signatories[len(m.Signatories)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 550 return err 551 } 552 iNdEx = postIndex 553 case 2: 554 if wireType != 2 { 555 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 556 } 557 var byteLen int 558 for shift := uint(0); ; shift += 7 { 559 if shift >= 64 { 560 return ErrIntOverflowTxs 561 } 562 if iNdEx >= l { 563 return io.ErrUnexpectedEOF 564 } 565 b := dAtA[iNdEx] 566 iNdEx++ 567 byteLen |= int(b&0x7F) << shift 568 if b < 0x80 { 569 break 570 } 571 } 572 if byteLen < 0 { 573 return ErrInvalidLengthTxs 574 } 575 postIndex := iNdEx + byteLen 576 if postIndex < 0 { 577 return ErrInvalidLengthTxs 578 } 579 if postIndex > l { 580 return io.ErrUnexpectedEOF 581 } 582 var v Tx 583 m.Tx = &v 584 if err := m.Tx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 585 return err 586 } 587 iNdEx = postIndex 588 default: 589 iNdEx = preIndex 590 skippy, err := skipTxs(dAtA[iNdEx:]) 591 if err != nil { 592 return err 593 } 594 if skippy < 0 { 595 return ErrInvalidLengthTxs 596 } 597 if (iNdEx + skippy) < 0 { 598 return ErrInvalidLengthTxs 599 } 600 if (iNdEx + skippy) > l { 601 return io.ErrUnexpectedEOF 602 } 603 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 604 iNdEx += skippy 605 } 606 } 607 608 if iNdEx > l { 609 return io.ErrUnexpectedEOF 610 } 611 return nil 612 } 613 func (m *Signatory) Unmarshal(dAtA []byte) error { 614 l := len(dAtA) 615 iNdEx := 0 616 for iNdEx < l { 617 preIndex := iNdEx 618 var wire uint64 619 for shift := uint(0); ; shift += 7 { 620 if shift >= 64 { 621 return ErrIntOverflowTxs 622 } 623 if iNdEx >= l { 624 return io.ErrUnexpectedEOF 625 } 626 b := dAtA[iNdEx] 627 iNdEx++ 628 wire |= uint64(b&0x7F) << shift 629 if b < 0x80 { 630 break 631 } 632 } 633 fieldNum := int32(wire >> 3) 634 wireType := int(wire & 0x7) 635 if wireType == 4 { 636 return fmt.Errorf("proto: Signatory: wiretype end group for non-group") 637 } 638 if fieldNum <= 0 { 639 return fmt.Errorf("proto: Signatory: illegal tag %d (wire type %d)", fieldNum, wire) 640 } 641 switch fieldNum { 642 case 1: 643 if wireType != 2 { 644 return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) 645 } 646 var byteLen int 647 for shift := uint(0); ; shift += 7 { 648 if shift >= 64 { 649 return ErrIntOverflowTxs 650 } 651 if iNdEx >= l { 652 return io.ErrUnexpectedEOF 653 } 654 b := dAtA[iNdEx] 655 iNdEx++ 656 byteLen |= int(b&0x7F) << shift 657 if b < 0x80 { 658 break 659 } 660 } 661 if byteLen < 0 { 662 return ErrInvalidLengthTxs 663 } 664 postIndex := iNdEx + byteLen 665 if postIndex < 0 { 666 return ErrInvalidLengthTxs 667 } 668 if postIndex > l { 669 return io.ErrUnexpectedEOF 670 } 671 var v github_com_hyperledger_burrow_crypto.Address 672 m.Address = &v 673 if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 674 return err 675 } 676 iNdEx = postIndex 677 case 2: 678 if wireType != 2 { 679 return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType) 680 } 681 var msglen int 682 for shift := uint(0); ; shift += 7 { 683 if shift >= 64 { 684 return ErrIntOverflowTxs 685 } 686 if iNdEx >= l { 687 return io.ErrUnexpectedEOF 688 } 689 b := dAtA[iNdEx] 690 iNdEx++ 691 msglen |= int(b&0x7F) << shift 692 if b < 0x80 { 693 break 694 } 695 } 696 if msglen < 0 { 697 return ErrInvalidLengthTxs 698 } 699 postIndex := iNdEx + msglen 700 if postIndex < 0 { 701 return ErrInvalidLengthTxs 702 } 703 if postIndex > l { 704 return io.ErrUnexpectedEOF 705 } 706 if m.PublicKey == nil { 707 m.PublicKey = &crypto.PublicKey{} 708 } 709 if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 710 return err 711 } 712 iNdEx = postIndex 713 case 4: 714 if wireType != 2 { 715 return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) 716 } 717 var msglen int 718 for shift := uint(0); ; shift += 7 { 719 if shift >= 64 { 720 return ErrIntOverflowTxs 721 } 722 if iNdEx >= l { 723 return io.ErrUnexpectedEOF 724 } 725 b := dAtA[iNdEx] 726 iNdEx++ 727 msglen |= int(b&0x7F) << shift 728 if b < 0x80 { 729 break 730 } 731 } 732 if msglen < 0 { 733 return ErrInvalidLengthTxs 734 } 735 postIndex := iNdEx + msglen 736 if postIndex < 0 { 737 return ErrInvalidLengthTxs 738 } 739 if postIndex > l { 740 return io.ErrUnexpectedEOF 741 } 742 if m.Signature == nil { 743 m.Signature = &crypto.Signature{} 744 } 745 if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 746 return err 747 } 748 iNdEx = postIndex 749 default: 750 iNdEx = preIndex 751 skippy, err := skipTxs(dAtA[iNdEx:]) 752 if err != nil { 753 return err 754 } 755 if skippy < 0 { 756 return ErrInvalidLengthTxs 757 } 758 if (iNdEx + skippy) < 0 { 759 return ErrInvalidLengthTxs 760 } 761 if (iNdEx + skippy) > l { 762 return io.ErrUnexpectedEOF 763 } 764 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 765 iNdEx += skippy 766 } 767 } 768 769 if iNdEx > l { 770 return io.ErrUnexpectedEOF 771 } 772 return nil 773 } 774 func (m *Receipt) Unmarshal(dAtA []byte) error { 775 l := len(dAtA) 776 iNdEx := 0 777 for iNdEx < l { 778 preIndex := iNdEx 779 var wire uint64 780 for shift := uint(0); ; shift += 7 { 781 if shift >= 64 { 782 return ErrIntOverflowTxs 783 } 784 if iNdEx >= l { 785 return io.ErrUnexpectedEOF 786 } 787 b := dAtA[iNdEx] 788 iNdEx++ 789 wire |= uint64(b&0x7F) << shift 790 if b < 0x80 { 791 break 792 } 793 } 794 fieldNum := int32(wire >> 3) 795 wireType := int(wire & 0x7) 796 if wireType == 4 { 797 return fmt.Errorf("proto: Receipt: wiretype end group for non-group") 798 } 799 if fieldNum <= 0 { 800 return fmt.Errorf("proto: Receipt: illegal tag %d (wire type %d)", fieldNum, wire) 801 } 802 switch fieldNum { 803 case 1: 804 if wireType != 0 { 805 return fmt.Errorf("proto: wrong wireType = %d for field TxType", wireType) 806 } 807 m.TxType = 0 808 for shift := uint(0); ; shift += 7 { 809 if shift >= 64 { 810 return ErrIntOverflowTxs 811 } 812 if iNdEx >= l { 813 return io.ErrUnexpectedEOF 814 } 815 b := dAtA[iNdEx] 816 iNdEx++ 817 m.TxType |= github_com_hyperledger_burrow_txs_payload.Type(b&0x7F) << shift 818 if b < 0x80 { 819 break 820 } 821 } 822 case 2: 823 if wireType != 2 { 824 return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType) 825 } 826 var byteLen int 827 for shift := uint(0); ; shift += 7 { 828 if shift >= 64 { 829 return ErrIntOverflowTxs 830 } 831 if iNdEx >= l { 832 return io.ErrUnexpectedEOF 833 } 834 b := dAtA[iNdEx] 835 iNdEx++ 836 byteLen |= int(b&0x7F) << shift 837 if b < 0x80 { 838 break 839 } 840 } 841 if byteLen < 0 { 842 return ErrInvalidLengthTxs 843 } 844 postIndex := iNdEx + byteLen 845 if postIndex < 0 { 846 return ErrInvalidLengthTxs 847 } 848 if postIndex > l { 849 return io.ErrUnexpectedEOF 850 } 851 if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 852 return err 853 } 854 iNdEx = postIndex 855 case 3: 856 if wireType != 0 { 857 return fmt.Errorf("proto: wrong wireType = %d for field CreatesContract", wireType) 858 } 859 var v int 860 for shift := uint(0); ; shift += 7 { 861 if shift >= 64 { 862 return ErrIntOverflowTxs 863 } 864 if iNdEx >= l { 865 return io.ErrUnexpectedEOF 866 } 867 b := dAtA[iNdEx] 868 iNdEx++ 869 v |= int(b&0x7F) << shift 870 if b < 0x80 { 871 break 872 } 873 } 874 m.CreatesContract = bool(v != 0) 875 case 4: 876 if wireType != 2 { 877 return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) 878 } 879 var byteLen int 880 for shift := uint(0); ; shift += 7 { 881 if shift >= 64 { 882 return ErrIntOverflowTxs 883 } 884 if iNdEx >= l { 885 return io.ErrUnexpectedEOF 886 } 887 b := dAtA[iNdEx] 888 iNdEx++ 889 byteLen |= int(b&0x7F) << shift 890 if b < 0x80 { 891 break 892 } 893 } 894 if byteLen < 0 { 895 return ErrInvalidLengthTxs 896 } 897 postIndex := iNdEx + byteLen 898 if postIndex < 0 { 899 return ErrInvalidLengthTxs 900 } 901 if postIndex > l { 902 return io.ErrUnexpectedEOF 903 } 904 if err := m.ContractAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 905 return err 906 } 907 iNdEx = postIndex 908 default: 909 iNdEx = preIndex 910 skippy, err := skipTxs(dAtA[iNdEx:]) 911 if err != nil { 912 return err 913 } 914 if skippy < 0 { 915 return ErrInvalidLengthTxs 916 } 917 if (iNdEx + skippy) < 0 { 918 return ErrInvalidLengthTxs 919 } 920 if (iNdEx + skippy) > l { 921 return io.ErrUnexpectedEOF 922 } 923 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 924 iNdEx += skippy 925 } 926 } 927 928 if iNdEx > l { 929 return io.ErrUnexpectedEOF 930 } 931 return nil 932 } 933 func skipTxs(dAtA []byte) (n int, err error) { 934 l := len(dAtA) 935 iNdEx := 0 936 for iNdEx < l { 937 var wire uint64 938 for shift := uint(0); ; shift += 7 { 939 if shift >= 64 { 940 return 0, ErrIntOverflowTxs 941 } 942 if iNdEx >= l { 943 return 0, io.ErrUnexpectedEOF 944 } 945 b := dAtA[iNdEx] 946 iNdEx++ 947 wire |= (uint64(b) & 0x7F) << shift 948 if b < 0x80 { 949 break 950 } 951 } 952 wireType := int(wire & 0x7) 953 switch wireType { 954 case 0: 955 for shift := uint(0); ; shift += 7 { 956 if shift >= 64 { 957 return 0, ErrIntOverflowTxs 958 } 959 if iNdEx >= l { 960 return 0, io.ErrUnexpectedEOF 961 } 962 iNdEx++ 963 if dAtA[iNdEx-1] < 0x80 { 964 break 965 } 966 } 967 return iNdEx, nil 968 case 1: 969 iNdEx += 8 970 return iNdEx, nil 971 case 2: 972 var length int 973 for shift := uint(0); ; shift += 7 { 974 if shift >= 64 { 975 return 0, ErrIntOverflowTxs 976 } 977 if iNdEx >= l { 978 return 0, io.ErrUnexpectedEOF 979 } 980 b := dAtA[iNdEx] 981 iNdEx++ 982 length |= (int(b) & 0x7F) << shift 983 if b < 0x80 { 984 break 985 } 986 } 987 if length < 0 { 988 return 0, ErrInvalidLengthTxs 989 } 990 iNdEx += length 991 if iNdEx < 0 { 992 return 0, ErrInvalidLengthTxs 993 } 994 return iNdEx, nil 995 case 3: 996 for { 997 var innerWire uint64 998 var start int = iNdEx 999 for shift := uint(0); ; shift += 7 { 1000 if shift >= 64 { 1001 return 0, ErrIntOverflowTxs 1002 } 1003 if iNdEx >= l { 1004 return 0, io.ErrUnexpectedEOF 1005 } 1006 b := dAtA[iNdEx] 1007 iNdEx++ 1008 innerWire |= (uint64(b) & 0x7F) << shift 1009 if b < 0x80 { 1010 break 1011 } 1012 } 1013 innerWireType := int(innerWire & 0x7) 1014 if innerWireType == 4 { 1015 break 1016 } 1017 next, err := skipTxs(dAtA[start:]) 1018 if err != nil { 1019 return 0, err 1020 } 1021 iNdEx = start + next 1022 if iNdEx < 0 { 1023 return 0, ErrInvalidLengthTxs 1024 } 1025 } 1026 return iNdEx, nil 1027 case 4: 1028 return iNdEx, nil 1029 case 5: 1030 iNdEx += 4 1031 return iNdEx, nil 1032 default: 1033 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1034 } 1035 } 1036 panic("unreachable") 1037 } 1038 1039 var ( 1040 ErrInvalidLengthTxs = fmt.Errorf("proto: negative length found during unmarshaling") 1041 ErrIntOverflowTxs = fmt.Errorf("proto: integer overflow") 1042 )