Skip to content

S
sidecar
Commit 3ac49d2d authored by harrylee's avatar harrylee
Browse files
Options

add result type

parent 58cc8183
Pipeline #8459 failed with stages
      Show whitespace changes
      Inline Side-by-side
      Showing with 164 additions and 1431 deletions
      model/pb/ibtp.go
      View file @ 3ac49d2d
      ...@@ -3,6 +3,8 @@ package pb ...@@ -3,6 +3,8 @@ package pb
      import ( import (
      "crypto/sha256" "crypto/sha256"
      "fmt" "fmt"
      "strconv"
      "strings"
      "github.com/meshplus/bitxhub-kit/types" "github.com/meshplus/bitxhub-kit/types"
      ) )
      ...@@ -40,3 +42,68 @@ func (m *IBTP) Category() IBTP_Category { ...@@ -40,3 +42,68 @@ func (m *IBTP) Category() IBTP_Category {
      } }
      return IBTP_UNKNOWN return IBTP_UNKNOWN
      } }
      func (m *IBTP) ServicePair() string {
      return fmt.Sprintf("%s-%s", m.From, m.To)
      }
      // ParseFrom should be called after CheckServiceID is called
      func (m *IBTP) ParseFrom() (string, string, string) {
      bxhID, chainID, serviceID, _ := ParseFullServiceID(m.From)
      return bxhID, chainID, serviceID
      }
      // ParseTo should be called after CheckServiceID is called
      func (m *IBTP) ParseTo() (string, string, string) {
      bxhID, chainID, serviceID, _ := ParseFullServiceID(m.To)
      return bxhID, chainID, serviceID
      }
      func (m *IBTP) CheckServiceID() error {
      _, _, _, err := ParseFullServiceID(m.From)
      if err != nil {
      return err
      }
      _, _, _, err = ParseFullServiceID(m.To)
      return err
      }
      func ParseFullServiceID(id string) (string, string, string, error) {
      splits := strings.Split(id, ":")
      if len(splits) != 3 {
      return "", "", "", fmt.Errorf("invalid full service ID: %s", id)
      }
      return splits[0], splits[1], splits[2], nil
      }
      func ParseServicePair(servicePair string) (string, string, error) {
      splits := strings.Split(servicePair, "-")
      if len(splits) != 2 {
      return "", "", fmt.Errorf("invalid service pair: %s", servicePair)
      }
      return splits[0], splits[1], nil
      }
      func ParseIBTPID(id string) (string, string, uint64, error) {
      splits := strings.Split(id, "-")
      if len(splits) != 3 {
      return "", "", 0, fmt.Errorf("invalid IBTP ID: %s", id)
      }
      index, err := strconv.Atoi(splits[2])
      if err != nil {
      return "", "", 0, fmt.Errorf("invalid IBTP ID: %s", id)
      }
      return splits[0], splits[1], uint64(index), nil
      }
      func GenServicePair(from, to string) string {
      return fmt.Sprintf("%s-%s", from, to)
      }
      model/pb/ibtp.pb.go
      View file @ 3ac49d2d
      // Code generated by protoc-gen-gogo. DO NOT EDIT. // Code generated by protoc-gen-go. DO NOT EDIT.
      // source: ibtp.proto // source: ibtp.proto
      package pb package pb
      import ( import (
      fmt "fmt" fmt "fmt"
      io "io" proto "github.com/golang/protobuf/proto"
      math "math" math "math"
      math_bits "math/bits"
      proto "github.com/gogo/protobuf/proto"
      ) )
      // Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal var _ = proto.Marshal
      var _ = fmt.Errorf var _ = fmt.Errorf
      var _ = math.Inf var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against. // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the // A compilation error at this line likely means your copy of the
      // proto package needs to be updated. // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
      type IBTP_Type int32 type IBTP_Type int32
      ...@@ -109,43 +104,30 @@ type IBTP struct { ...@@ -109,43 +104,30 @@ type IBTP struct {
      Version string `protobuf:"bytes,9,opt,name=version,proto3" json:"version,omitempty"` Version string `protobuf:"bytes,9,opt,name=version,proto3" json:"version,omitempty"`
      // Self-defined fields used by app-chain // Self-defined fields used by app-chain
      Extra []byte `protobuf:"bytes,10,opt,name=extra,proto3" json:"extra,omitempty"` Extra []byte `protobuf:"bytes,10,opt,name=extra,proto3" json:"extra,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      } }
      func (m *IBTP) Reset() { *m = IBTP{} } func (m *IBTP) Reset() { *m = IBTP{} }
      func (m *IBTP) String() string { return proto.CompactTextString(m) } func (m *IBTP) String() string { return proto.CompactTextString(m) }
      func (*IBTP) ProtoMessage() {} func (*IBTP) ProtoMessage() {}
      func (*IBTP) Descriptor() ([]byte, []int) { func (*IBTP) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{0} return fileDescriptor_7576a0a5bf0190a3, []int{0}
      } }
      func (m *IBTP) XXX_Unmarshal(b []byte) error { func (m *IBTP) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b) return xxx_messageInfo_IBTP.Unmarshal(m, b)
      } }
      func (m *IBTP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *IBTP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_IBTP.Marshal(b, m, deterministic) return xxx_messageInfo_IBTP.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 *IBTP) XXX_Merge(src proto.Message) { func (m *IBTP) XXX_Merge(src proto.Message) {
      xxx_messageInfo_IBTP.Merge(m, src) xxx_messageInfo_IBTP.Merge(m, src)
      } }
      func (m *IBTP) XXX_Size() int { func (m *IBTP) XXX_Size() int {
      return m.Size() return xxx_messageInfo_IBTP.Size(m)
      } }
      func (m *IBTP) XXX_DiscardUnknown() { func (m *IBTP) XXX_DiscardUnknown() {
      xxx_messageInfo_IBTP.DiscardUnknown(m) xxx_messageInfo_IBTP.DiscardUnknown(m)
      } }
      ...@@ -225,43 +207,30 @@ func (m *IBTP) GetExtra() []byte { ...@@ -225,43 +207,30 @@ func (m *IBTP) GetExtra() []byte {
      type Payload struct { type Payload struct {
      Encrypted bool `protobuf:"varint,1,opt,name=encrypted,proto3" json:"encrypted,omitempty"` Encrypted bool `protobuf:"varint,1,opt,name=encrypted,proto3" json:"encrypted,omitempty"`
      Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      } }
      func (m *Payload) Reset() { *m = Payload{} } func (m *Payload) Reset() { *m = Payload{} }
      func (m *Payload) String() string { return proto.CompactTextString(m) } func (m *Payload) String() string { return proto.CompactTextString(m) }
      func (*Payload) ProtoMessage() {} func (*Payload) ProtoMessage() {}
      func (*Payload) Descriptor() ([]byte, []int) { func (*Payload) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{1} return fileDescriptor_7576a0a5bf0190a3, []int{1}
      } }
      func (m *Payload) XXX_Unmarshal(b []byte) error { func (m *Payload) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b) return xxx_messageInfo_Payload.Unmarshal(m, b)
      } }
      func (m *Payload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *Payload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_Payload.Marshal(b, m, deterministic) return xxx_messageInfo_Payload.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 *Payload) XXX_Merge(src proto.Message) { func (m *Payload) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Payload.Merge(m, src) xxx_messageInfo_Payload.Merge(m, src)
      } }
      func (m *Payload) XXX_Size() int { func (m *Payload) XXX_Size() int {
      return m.Size() return xxx_messageInfo_Payload.Size(m)
      } }
      func (m *Payload) XXX_DiscardUnknown() { func (m *Payload) XXX_DiscardUnknown() {
      xxx_messageInfo_Payload.DiscardUnknown(m) xxx_messageInfo_Payload.DiscardUnknown(m)
      } }
      ...@@ -291,43 +260,30 @@ type Content struct { ...@@ -291,43 +260,30 @@ type Content struct {
      ArgsCb [][]byte `protobuf:"bytes,6,rep,name=argsCb,proto3" json:"argsCb,omitempty"` ArgsCb [][]byte `protobuf:"bytes,6,rep,name=argsCb,proto3" json:"argsCb,omitempty"`
      Rollback string `protobuf:"bytes,7,opt,name=rollback,proto3" json:"rollback,omitempty"` Rollback string `protobuf:"bytes,7,opt,name=rollback,proto3" json:"rollback,omitempty"`
      ArgsRb [][]byte `protobuf:"bytes,8,rep,name=argsRb,proto3" json:"argsRb,omitempty"` ArgsRb [][]byte `protobuf:"bytes,8,rep,name=argsRb,proto3" json:"argsRb,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      } }
      func (m *Content) Reset() { *m = Content{} } func (m *Content) Reset() { *m = Content{} }
      func (m *Content) String() string { return proto.CompactTextString(m) } func (m *Content) String() string { return proto.CompactTextString(m) }
      func (*Content) ProtoMessage() {} func (*Content) ProtoMessage() {}
      func (*Content) Descriptor() ([]byte, []int) { func (*Content) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{2} return fileDescriptor_7576a0a5bf0190a3, []int{2}
      } }
      func (m *Content) XXX_Unmarshal(b []byte) error { func (m *Content) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b) return xxx_messageInfo_Content.Unmarshal(m, b)
      } }
      func (m *Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_Content.Marshal(b, m, deterministic) return xxx_messageInfo_Content.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 *Content) XXX_Merge(src proto.Message) { func (m *Content) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Content.Merge(m, src) xxx_messageInfo_Content.Merge(m, src)
      } }
      func (m *Content) XXX_Size() int { func (m *Content) XXX_Size() int {
      return m.Size() return xxx_messageInfo_Content.Size(m)
      } }
      func (m *Content) XXX_DiscardUnknown() { func (m *Content) XXX_DiscardUnknown() {
      xxx_messageInfo_Content.DiscardUnknown(m) xxx_messageInfo_Content.DiscardUnknown(m)
      } }
      ...@@ -392,43 +348,30 @@ func (m *Content) GetArgsRb() [][]byte { ...@@ -392,43 +348,30 @@ func (m *Content) GetArgsRb() [][]byte {
      type IBTPs struct { type IBTPs struct {
      Ibtps []*IBTP `protobuf:"bytes,1,rep,name=ibtps,proto3" json:"ibtps,omitempty"` Ibtps []*IBTP `protobuf:"bytes,1,rep,name=ibtps,proto3" json:"ibtps,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      } }
      func (m *IBTPs) Reset() { *m = IBTPs{} } func (m *IBTPs) Reset() { *m = IBTPs{} }
      func (m *IBTPs) String() string { return proto.CompactTextString(m) } func (m *IBTPs) String() string { return proto.CompactTextString(m) }
      func (*IBTPs) ProtoMessage() {} func (*IBTPs) ProtoMessage() {}
      func (*IBTPs) Descriptor() ([]byte, []int) { func (*IBTPs) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{3} return fileDescriptor_7576a0a5bf0190a3, []int{3}
      } }
      func (m *IBTPs) XXX_Unmarshal(b []byte) error { func (m *IBTPs) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b) return xxx_messageInfo_IBTPs.Unmarshal(m, b)
      } }
      func (m *IBTPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *IBTPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_IBTPs.Marshal(b, m, deterministic) return xxx_messageInfo_IBTPs.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 *IBTPs) XXX_Merge(src proto.Message) { func (m *IBTPs) XXX_Merge(src proto.Message) {
      xxx_messageInfo_IBTPs.Merge(m, src) xxx_messageInfo_IBTPs.Merge(m, src)
      } }
      func (m *IBTPs) XXX_Size() int { func (m *IBTPs) XXX_Size() int {
      return m.Size() return xxx_messageInfo_IBTPs.Size(m)
      } }
      func (m *IBTPs) XXX_DiscardUnknown() { func (m *IBTPs) XXX_DiscardUnknown() {
      xxx_messageInfo_IBTPs.DiscardUnknown(m) xxx_messageInfo_IBTPs.DiscardUnknown(m)
      } }
      ...@@ -442,1374 +385,93 @@ func (m *IBTPs) GetIbtps() []*IBTP { ...@@ -442,1374 +385,93 @@ func (m *IBTPs) GetIbtps() []*IBTP {
      return nil return nil
      } }
      func init() { type Result struct {
      proto.RegisterEnum("pb.IBTP_Type", IBTP_Type_name, IBTP_Type_value) Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
      proto.RegisterEnum("pb.IBTP_Category", IBTP_Category_name, IBTP_Category_value) XXX_NoUnkeyedLiteral struct{} `json:"-"`
      proto.RegisterType((*IBTP)(nil), "pb.IBTP") XXX_unrecognized []byte `json:"-"`
      proto.RegisterType((*Payload)(nil), "pb.payload") XXX_sizecache int32 `json:"-"`
      proto.RegisterType((*Content)(nil), "pb.content")
      proto.RegisterType((*IBTPs)(nil), "pb.IBTPs")
      }
      func init() { proto.RegisterFile("ibtp.proto", fileDescriptor_7576a0a5bf0190a3) }
      var fileDescriptor_7576a0a5bf0190a3 = []byte{
      // 551 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x53, 0xcd, 0x6e, 0xd3, 0x4c,
      0x14, 0xcd, 0xc4, 0x4e, 0xe2, 0xdc, 0xa4, 0xad, 0x35, 0xad, 0x3e, 0x8d, 0xaa, 0x4f, 0x96, 0xf1,
      0x02, 0xcc, 0x26, 0x8b, 0x80, 0xd8, 0xa7, 0x96, 0x11, 0x56, 0x8b, 0x5b, 0xc6, 0x89, 0x58, 0x56,
      0xfe, 0x6b, 0x64, 0xd1, 0x7a, 0x46, 0xe3, 0x29, 0x22, 0x6f, 0xc1, 0x53, 0xf0, 0x2c, 0x2c, 0xbb,
      0x64, 0x89, 0xda, 0x15, 0x6f, 0x81, 0x66, 0x1c, 0x27, 0x65, 0x37, 0xe7, 0xdc, 0x73, 0xee, 0xf5,
      0xcc, 0x3d, 0x06, 0xa8, 0x32, 0xc9, 0x67, 0x5c, 0x30, 0xc9, 0x70, 0x9f, 0x67, 0xa7, 0x93, 0x2c,
      0x6d, 0xaa, 0xbc, 0x25, 0xbc, 0x1f, 0x06, 0x98, 0xd1, 0xd9, 0xf2, 0x0a, 0x63, 0x30, 0x6f, 0x04,
      0xbb, 0x23, 0xc8, 0x45, 0xfe, 0x98, 0xea, 0x33, 0x3e, 0x84, 0xbe, 0x64, 0xa4, 0xaf, 0x99, 0xbe,
      0x64, 0xf8, 0x04, 0x06, 0x35, 0xab, 0xf3, 0x92, 0x18, 0x2e, 0xf2, 0x4d, 0xda, 0x02, 0xfc, 0x02,
      0x4c, 0xb9, 0xe1, 0x25, 0x31, 0x5d, 0xe4, 0x1f, 0xce, 0x0f, 0x66, 0x3c, 0x9b, 0xa9, 0x8e, 0xb3,
      0xe5, 0x86, 0x97, 0x54, 0x97, 0xf0, 0xff, 0x30, 0x96, 0xd5, 0x5d, 0xd9, 0xc8, 0xf4, 0x8e, 0x93,
      0x81, 0x8b, 0x7c, 0x83, 0xee, 0x09, 0xd5, 0x96, 0x0b, 0xc6, 0x6e, 0xc8, 0xd0, 0x45, 0xfe, 0x94,
      0xb6, 0x00, 0x13, 0x18, 0xf1, 0x74, 0x73, 0xcb, 0xd2, 0x82, 0x8c, 0x34, 0xdf, 0x41, 0xfc, 0x1a,
      0x06, 0x6b, 0xc1, 0xee, 0x39, 0xb1, 0x5c, 0xe4, 0x4f, 0xe6, 0xc7, 0x6a, 0x62, 0x22, 0x45, 0x55,
      0xaf, 0x57, 0x55, 0x2d, 0xdf, 0xbd, 0xfd, 0x98, 0x72, 0xda, 0x2a, 0x54, 0x93, 0xaf, 0xa5, 0x68,
      0x2a, 0x56, 0x93, 0xb1, 0xbe, 0x46, 0x07, 0xd5, 0xd0, 0xf2, 0x9b, 0x14, 0x29, 0x81, 0x76, 0xa8,
      0x06, 0x5e, 0x01, 0xa6, 0xfa, 0x6c, 0x7c, 0x08, 0x10, 0xc5, 0xcb, 0x90, 0x06, 0x1f, 0x16, 0x51,
      0x6c, 0xf7, 0xf0, 0x31, 0x1c, 0xd1, 0x30, 0x08, 0xa3, 0xab, 0xe5, 0x75, 0xb2, 0x0a, 0x82, 0x30,
      0x49, 0x6c, 0xf4, 0x9c, 0x7c, 0xbf, 0x88, 0x2e, 0x56, 0x34, 0xb4, 0xfb, 0x78, 0x0a, 0x16, 0xbd,
      0xbc, 0xb8, 0x38, 0x5b, 0x04, 0xe7, 0xb6, 0x81, 0x4f, 0xc0, 0xee, 0x24, 0x3b, 0xd6, 0xf4, 0xe6,
      0x60, 0x05, 0xa9, 0x2c, 0xd7, 0x4c, 0x6c, 0xf0, 0x04, 0x46, 0x34, 0xfc, 0xb4, 0x0a, 0x93, 0xa5,
      0xdd, 0xd3, 0xe6, 0x30, 0xb9, 0xba, 0x8c, 0x93, 0xd0, 0x46, 0xaa, 0xb4, 0x8a, 0xcf, 0xe3, 0xcb,
      0xcf, 0xb1, 0xdd, 0xf7, 0x16, 0xbb, 0xe7, 0x50, 0xaf, 0x59, 0xd6, 0xb9, 0xd8, 0x70, 0x59, 0x16,
      0x7a, 0x5f, 0x16, 0xdd, 0x13, 0xea, 0xca, 0x39, 0xab, 0x65, 0x59, 0x4b, 0xbd, 0xb9, 0x29, 0xed,
      0xa0, 0xf7, 0x07, 0xed, 0x4a, 0xf8, 0x25, 0x1c, 0x35, 0x22, 0xbf, 0x56, 0x50, 0xa4, 0xb9, 0xbc,
      0xae, 0x8a, 0xed, 0xe6, 0x0f, 0x1a, 0x91, 0x07, 0x5b, 0x36, 0x2a, 0x94, 0xae, 0x68, 0xe4, 0x3f,
      0xba, 0x36, 0x0f, 0x07, 0x45, 0x23, 0x9f, 0xe9, 0x54, 0x7c, 0xee, 0xeb, 0x5c, 0x27, 0x43, 0xc5,
      0xe7, 0xbe, 0xce, 0x15, 0x97, 0x8a, 0x75, 0x43, 0x4c, 0xd7, 0xf0, 0xa7, 0x54, 0x9f, 0xf1, 0x29,
      0x58, 0x79, 0x7a, 0x7b, 0x9b, 0xa5, 0xf9, 0x17, 0x1d, 0x84, 0x31, 0xdd, 0x61, 0xfc, 0x1f, 0x0c,
      0x95, 0x26, 0xc8, 0xc8, 0x50, 0x3b, 0xb6, 0x48, 0x79, 0x04, 0xdb, 0x7a, 0x46, 0xad, 0xa7, 0xc3,
      0x9d, 0x87, 0x66, 0xc4, 0xda, 0x7b, 0x68, 0xe6, 0xbd, 0x82, 0x81, 0x0a, 0x61, 0x83, 0x1d, 0x18,
      0xa8, 0xfc, 0x37, 0x04, 0xb9, 0x86, 0x3f, 0x99, 0x5b, 0x5d, 0x3c, 0x69, 0x4b, 0x9f, 0x91, 0x9f,
      0x8f, 0x0e, 0x7a, 0x78, 0x74, 0xd0, 0xef, 0x47, 0x07, 0x7d, 0x7f, 0x72, 0x7a, 0x0f, 0x4f, 0x4e,
      0xef, 0xd7, 0x93, 0xd3, 0xcb, 0x86, 0xfa, 0x0f, 0x79, 0xf3, 0x37, 0x00, 0x00, 0xff, 0xff, 0xf4,
      0x8e, 0xc3, 0xc2, 0x40, 0x03, 0x00, 0x00,
      }
      func (m *IBTP) 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 *IBTP) MarshalTo(dAtA []byte) (int, error) {
      size := m.Size()
      return m.MarshalToSizedBuffer(dAtA[:size])
      }
      func (m *IBTP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
      i := len(dAtA)
      _ = i
      var l int
      _ = l
      if len(m.Extra) > 0 {
      i -= len(m.Extra)
      copy(dAtA[i:], m.Extra)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Extra)))
      i--
      dAtA[i] = 0x52
      }
      if len(m.Version) > 0 {
      i -= len(m.Version)
      copy(dAtA[i:], m.Version)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Version)))
      i--
      dAtA[i] = 0x4a
      }
      if m.Group != nil {
      {
      size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
      if err != nil {
      return 0, err
      }
      i -= size
      i = encodeVarintIbtp(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x42
      }
      if len(m.Payload) > 0 {
      i -= len(m.Payload)
      copy(dAtA[i:], m.Payload)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Payload)))
      i--
      dAtA[i] = 0x3a
      }
      if len(m.Proof) > 0 {
      i -= len(m.Proof)
      copy(dAtA[i:], m.Proof)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Proof)))
      i--
      dAtA[i] = 0x32
      }
      if m.Timestamp != 0 {
      i = encodeVarintIbtp(dAtA, i, uint64(m.Timestamp))
      i--
      dAtA[i] = 0x28
      }
      if m.Type != 0 {
      i = encodeVarintIbtp(dAtA, i, uint64(m.Type))
      i--
      dAtA[i] = 0x20
      }
      if m.Nonce != 0 {
      i = encodeVarintIbtp(dAtA, i, uint64(m.Nonce))
      i--
      dAtA[i] = 0x18
      }
      if len(m.To) > 0 {
      i -= len(m.To)
      copy(dAtA[i:], m.To)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.To)))
      i--
      dAtA[i] = 0x12
      }
      if len(m.From) > 0 {
      i -= len(m.From)
      copy(dAtA[i:], m.From)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.From)))
      i--
      dAtA[i] = 0xa
      }
      return len(dAtA) - i, nil
      }
      func (m *Payload) 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 *Payload) MarshalTo(dAtA []byte) (int, error) {
      size := m.Size()
      return m.MarshalToSizedBuffer(dAtA[:size])
      }
      func (m *Payload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
      i := len(dAtA)
      _ = i
      var l int
      _ = l
      if len(m.Content) > 0 {
      i -= len(m.Content)
      copy(dAtA[i:], m.Content)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Content)))
      i--
      dAtA[i] = 0x12
      }
      if m.Encrypted {
      i--
      if m.Encrypted {
      dAtA[i] = 1
      } else {
      dAtA[i] = 0
      }
      i--
      dAtA[i] = 0x8
      }
      return len(dAtA) - i, nil
      }
      func (m *Content) 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 *Content) MarshalTo(dAtA []byte) (int, error) {
      size := m.Size()
      return m.MarshalToSizedBuffer(dAtA[:size])
      }
      func (m *Content) MarshalToSizedBuffer(dAtA []byte) (int, error) {
      i := len(dAtA)
      _ = i
      var l int
      _ = l
      if len(m.ArgsRb) > 0 {
      for iNdEx := len(m.ArgsRb) - 1; iNdEx >= 0; iNdEx-- {
      i -= len(m.ArgsRb[iNdEx])
      copy(dAtA[i:], m.ArgsRb[iNdEx])
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.ArgsRb[iNdEx])))
      i--
      dAtA[i] = 0x42
      }
      }
      if len(m.Rollback) > 0 {
      i -= len(m.Rollback)
      copy(dAtA[i:], m.Rollback)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Rollback)))
      i--
      dAtA[i] = 0x3a
      }
      if len(m.ArgsCb) > 0 {
      for iNdEx := len(m.ArgsCb) - 1; iNdEx >= 0; iNdEx-- {
      i -= len(m.ArgsCb[iNdEx])
      copy(dAtA[i:], m.ArgsCb[iNdEx])
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.ArgsCb[iNdEx])))
      i--
      dAtA[i] = 0x32
      }
      }
      if len(m.Callback) > 0 {
      i -= len(m.Callback)
      copy(dAtA[i:], m.Callback)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Callback)))
      i--
      dAtA[i] = 0x2a
      }
      if len(m.Args) > 0 {
      for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
      i -= len(m.Args[iNdEx])
      copy(dAtA[i:], m.Args[iNdEx])
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Args[iNdEx])))
      i--
      dAtA[i] = 0x22
      }
      }
      if len(m.Func) > 0 {
      i -= len(m.Func)
      copy(dAtA[i:], m.Func)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Func)))
      i--
      dAtA[i] = 0x1a
      }
      if len(m.DstContractId) > 0 {
      i -= len(m.DstContractId)
      copy(dAtA[i:], m.DstContractId)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.DstContractId)))
      i--
      dAtA[i] = 0x12
      }
      if len(m.SrcContractId) > 0 {
      i -= len(m.SrcContractId)
      copy(dAtA[i:], m.SrcContractId)
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.SrcContractId)))
      i--
      dAtA[i] = 0xa
      }
      return len(dAtA) - i, nil
      }
      func (m *IBTPs) 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 *IBTPs) MarshalTo(dAtA []byte) (int, error) {
      size := m.Size()
      return m.MarshalToSizedBuffer(dAtA[:size])
      }
      func (m *IBTPs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
      i := len(dAtA)
      _ = i
      var l int
      _ = l
      if len(m.Ibtps) > 0 {
      for iNdEx := len(m.Ibtps) - 1; iNdEx >= 0; iNdEx-- {
      {
      size, err := m.Ibtps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
      if err != nil {
      return 0, err
      }
      i -= size
      i = encodeVarintIbtp(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0xa
      }
      }
      return len(dAtA) - i, nil
      }
      func encodeVarintIbtp(dAtA []byte, offset int, v uint64) int {
      offset -= sovIbtp(v)
      base := offset
      for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
      }
      dAtA[offset] = uint8(v)
      return base
      }
      func (m *IBTP) Size() (n int) {
      if m == nil {
      return 0
      }
      var l int
      _ = l
      l = len(m.From)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.To)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      if m.Nonce != 0 {
      n += 1 + sovIbtp(uint64(m.Nonce))
      }
      if m.Type != 0 {
      n += 1 + sovIbtp(uint64(m.Type))
      }
      if m.Timestamp != 0 {
      n += 1 + sovIbtp(uint64(m.Timestamp))
      }
      l = len(m.Proof)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.Payload)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      if m.Group != nil {
      l = m.Group.Size()
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.Version)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.Extra)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      return n
      } }
      func (m *Payload) Size() (n int) { func (m *Result) Reset() { *m = Result{} }
      if m == nil { func (m *Result) String() string { return proto.CompactTextString(m) }
      return 0 func (*Result) ProtoMessage() {}
      } func (*Result) Descriptor() ([]byte, []int) {
      var l int return fileDescriptor_7576a0a5bf0190a3, []int{4}
      _ = l
      if m.Encrypted {
      n += 2
      }
      l = len(m.Content)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      return n
      } }
      func (m *Content) Size() (n int) { func (m *Result) XXX_Unmarshal(b []byte) error {
      if m == nil { return xxx_messageInfo_Result.Unmarshal(m, b)
      return 0
      }
      var l int
      _ = l
      l = len(m.SrcContractId)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.DstContractId)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      l = len(m.Func)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      if len(m.Args) > 0 {
      for _, b := range m.Args {
      l = len(b)
      n += 1 + l + sovIbtp(uint64(l))
      }
      }
      l = len(m.Callback)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      if len(m.ArgsCb) > 0 {
      for _, b := range m.ArgsCb {
      l = len(b)
      n += 1 + l + sovIbtp(uint64(l))
      }
      }
      l = len(m.Rollback)
      if l > 0 {
      n += 1 + l + sovIbtp(uint64(l))
      }
      if len(m.ArgsRb) > 0 {
      for _, b := range m.ArgsRb {
      l = len(b)
      n += 1 + l + sovIbtp(uint64(l))
      }
      }
      return n
      } }
      func (m *Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      func (m *IBTPs) Size() (n int) { return xxx_messageInfo_Result.Marshal(b, m, deterministic)
      if m == nil {
      return 0
      }
      var l int
      _ = l
      if len(m.Ibtps) > 0 {
      for _, e := range m.Ibtps {
      l = e.Size()
      n += 1 + l + sovIbtp(uint64(l))
      }
      }
      return n
      } }
      func (m *Result) XXX_Merge(src proto.Message) {
      func sovIbtp(x uint64) (n int) { xxx_messageInfo_Result.Merge(m, src)
      return (math_bits.Len64(x|1) + 6) / 7
      } }
      func (m *Result) XXX_Size() int {
      func sozIbtp(x uint64) (n int) { return xxx_messageInfo_Result.Size(m)
      return sovIbtp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
      } }
      func (m *Result) XXX_DiscardUnknown() {
      func (m *IBTP) Unmarshal(dAtA []byte) error { xxx_messageInfo_Result.DiscardUnknown(m)
      l := len(dAtA)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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: IBTP: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
      return fmt.Errorf("proto: IBTP: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.From = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 2:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.To = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 3:
      if wireType != 0 {
      return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
      }
      m.Nonce = 0
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      m.Nonce |= uint64(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      case 4:
      if wireType != 0 {
      return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
      }
      m.Type = 0
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      m.Type |= IBTP_Type(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      case 5:
      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 ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      m.Timestamp |= int64(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      case 6:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
      if m.Proof == nil {
      m.Proof = []byte{}
      }
      iNdEx = postIndex
      case 7:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
      if m.Payload == nil {
      m.Payload = []byte{}
      }
      iNdEx = postIndex
      case 8:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
      }
      var msglen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      msglen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if msglen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + msglen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      if m.Group == nil {
      m.Group = &StringUint64Map{}
      }
      if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
      return err
      }
      iNdEx = postIndex
      case 9:
      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 ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Version = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 10:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Extra = append(m.Extra[:0], dAtA[iNdEx:postIndex]...)
      if m.Extra == nil {
      m.Extra = []byte{}
      }
      iNdEx = postIndex
      default:
      iNdEx = preIndex
      skippy, err := skipIbtp(dAtA[iNdEx:])
      if err != nil {
      return err
      }
      if (skippy < 0) || (iNdEx+skippy) < 0 {
      return ErrInvalidLengthIbtp
      }
      if (iNdEx + skippy) > l {
      return io.ErrUnexpectedEOF
      }
      iNdEx += skippy
      }
      }
      if iNdEx > l {
      return io.ErrUnexpectedEOF
      }
      return nil
      } }
      func (m *Payload) Unmarshal(dAtA []byte) error { var xxx_messageInfo_Result proto.InternalMessageInfo
      l := len(dAtA)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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: payload: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
      return fmt.Errorf("proto: payload: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
      if wireType != 0 {
      return fmt.Errorf("proto: wrong wireType = %d for field Encrypted", wireType)
      }
      var v int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      v |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      m.Encrypted = bool(v != 0)
      case 2:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)
      if m.Content == nil {
      m.Content = []byte{}
      }
      iNdEx = postIndex
      default:
      iNdEx = preIndex
      skippy, err := skipIbtp(dAtA[iNdEx:])
      if err != nil {
      return err
      }
      if (skippy < 0) || (iNdEx+skippy) < 0 {
      return ErrInvalidLengthIbtp
      }
      if (iNdEx + skippy) > l {
      return io.ErrUnexpectedEOF
      }
      iNdEx += skippy
      }
      }
      if iNdEx > l { func (m *Result) GetData() [][]byte {
      return io.ErrUnexpectedEOF if m != nil {
      return m.Data
      } }
      return nil return nil
      } }
      func (m *Content) Unmarshal(dAtA []byte) error { func init() {
      l := len(dAtA) proto.RegisterEnum("pb.IBTP_Type", IBTP_Type_name, IBTP_Type_value)
      iNdEx := 0 proto.RegisterEnum("pb.IBTP_Category", IBTP_Category_name, IBTP_Category_value)
      for iNdEx < l { proto.RegisterType((*IBTP)(nil), "pb.IBTP")
      preIndex := iNdEx proto.RegisterType((*Payload)(nil), "pb.payload")
      var wire uint64 proto.RegisterType((*Content)(nil), "pb.content")
      for shift := uint(0); ; shift += 7 { proto.RegisterType((*IBTPs)(nil), "pb.IBTPs")
      if shift >= 64 { proto.RegisterType((*Result)(nil), "pb.result")
      return ErrIntOverflowIbtp
      }
      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: content: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
      return fmt.Errorf("proto: content: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field SrcContractId", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.SrcContractId = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 2:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field DstContractId", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.DstContractId = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 3:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Func", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Func = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 4:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Args = append(m.Args, make([]byte, postIndex-iNdEx))
      copy(m.Args[len(m.Args)-1], dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 5:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Callback", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Callback = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 6:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field ArgsCb", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.ArgsCb = append(m.ArgsCb, make([]byte, postIndex-iNdEx))
      copy(m.ArgsCb[len(m.ArgsCb)-1], dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 7:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Rollback", wireType)
      }
      var stringLen uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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 ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + intStringLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Rollback = string(dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      case 8:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field ArgsRb", wireType)
      }
      var byteLen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      byteLen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if byteLen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + byteLen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.ArgsRb = append(m.ArgsRb, make([]byte, postIndex-iNdEx))
      copy(m.ArgsRb[len(m.ArgsRb)-1], dAtA[iNdEx:postIndex])
      iNdEx = postIndex
      default:
      iNdEx = preIndex
      skippy, err := skipIbtp(dAtA[iNdEx:])
      if err != nil {
      return err
      }
      if (skippy < 0) || (iNdEx+skippy) < 0 {
      return ErrInvalidLengthIbtp
      }
      if (iNdEx + skippy) > l {
      return io.ErrUnexpectedEOF
      }
      iNdEx += skippy
      }
      }
      if iNdEx > l {
      return io.ErrUnexpectedEOF
      }
      return nil
      } }
      func (m *IBTPs) Unmarshal(dAtA []byte) error { func init() {
      l := len(dAtA) proto.RegisterFile("ibtp.proto", fileDescriptor_7576a0a5bf0190a3)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      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: IBTPs: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
      return fmt.Errorf("proto: IBTPs: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Ibtps", wireType)
      }
      var msglen int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      msglen |= int(b&0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      if msglen < 0 {
      return ErrInvalidLengthIbtp
      }
      postIndex := iNdEx + msglen
      if postIndex < 0 {
      return ErrInvalidLengthIbtp
      }
      if postIndex > l {
      return io.ErrUnexpectedEOF
      }
      m.Ibtps = append(m.Ibtps, &IBTP{})
      if err := m.Ibtps[len(m.Ibtps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
      return err
      }
      iNdEx = postIndex
      default:
      iNdEx = preIndex
      skippy, err := skipIbtp(dAtA[iNdEx:])
      if err != nil {
      return err
      }
      if (skippy < 0) || (iNdEx+skippy) < 0 {
      return ErrInvalidLengthIbtp
      }
      if (iNdEx + skippy) > l {
      return io.ErrUnexpectedEOF
      }
      iNdEx += skippy
      }
      }
      if iNdEx > l {
      return io.ErrUnexpectedEOF
      }
      return nil
      } }
      func skipIbtp(dAtA []byte) (n int, err error) { var fileDescriptor_7576a0a5bf0190a3 = []byte{
      l := len(dAtA) // 534 bytes of a gzipped FileDescriptorProto
      iNdEx := 0 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x53, 0xcd, 0x8e, 0xda, 0x3c,
      depth := 0 0x14, 0x9d, 0xfc, 0x00, 0xe1, 0xc2, 0xcc, 0x44, 0x9e, 0xd1, 0x27, 0x6b, 0x34, 0xfa, 0x94, 0x66,
      for iNdEx < l { 0xd1, 0xa6, 0x1b, 0x16, 0xb4, 0xea, 0x9e, 0x89, 0x52, 0x35, 0x1a, 0x1a, 0xa8, 0x03, 0xea, 0x12,
      var wire uint64 0x39, 0x3f, 0x83, 0xa2, 0x42, 0x6c, 0x39, 0xa6, 0x2a, 0x2f, 0xd4, 0x77, 0xeb, 0x5b, 0x54, 0x76,
      for shift := uint(0); ; shift += 7 { 0x08, 0x4c, 0x77, 0x3e, 0xe7, 0x9e, 0x73, 0x6f, 0xec, 0x7b, 0x02, 0x50, 0x65, 0x92, 0x4f, 0xb8,
      if shift >= 64 { 0x60, 0x92, 0x21, 0x93, 0x67, 0x0f, 0xa3, 0x8c, 0x36, 0x55, 0xde, 0x12, 0xfe, 0x6f, 0x0b, 0xec,
      return 0, ErrIntOverflowIbtp 0xf8, 0x69, 0xb5, 0x44, 0x08, 0xec, 0x17, 0xc1, 0xf6, 0xd8, 0xf0, 0x8c, 0x60, 0x48, 0xf4, 0x19,
      } 0xdd, 0x80, 0x29, 0x19, 0x36, 0x35, 0x63, 0x4a, 0x86, 0xee, 0xa1, 0x57, 0xb3, 0x3a, 0x2f, 0xb1,
      if iNdEx >= l { 0xe5, 0x19, 0x81, 0x4d, 0x5a, 0x80, 0xde, 0x80, 0x2d, 0x8f, 0xbc, 0xc4, 0xb6, 0x67, 0x04, 0x37,
      return 0, io.ErrUnexpectedEOF 0xd3, 0xeb, 0x09, 0xcf, 0x26, 0xaa, 0xe3, 0x64, 0x75, 0xe4, 0x25, 0xd1, 0x25, 0xf4, 0x08, 0x43,
      } 0x59, 0xed, 0xcb, 0x46, 0xd2, 0x3d, 0xc7, 0x3d, 0xcf, 0x08, 0x2c, 0x72, 0x21, 0x54, 0x5b, 0x2e,
      b := dAtA[iNdEx] 0x18, 0x7b, 0xc1, 0x7d, 0xcf, 0x08, 0xc6, 0xa4, 0x05, 0x08, 0xc3, 0x80, 0xd3, 0xe3, 0x8e, 0xd1,
      iNdEx++ 0x02, 0x0f, 0x34, 0xdf, 0x41, 0xf4, 0x1e, 0x7a, 0x5b, 0xc1, 0x0e, 0x1c, 0x3b, 0x9e, 0x11, 0x8c,
      wire |= (uint64(b) & 0x7F) << shift 0xa6, 0x77, 0x6a, 0x62, 0x2a, 0x45, 0x55, 0x6f, 0xd7, 0x55, 0x2d, 0x3f, 0x7d, 0xfc, 0x4a, 0x39,
      if b < 0x80 { 0x69, 0x15, 0xaa, 0xc9, 0xcf, 0x52, 0x34, 0x15, 0xab, 0xf1, 0x50, 0x5f, 0xa3, 0x83, 0x6a, 0x68,
      break 0xf9, 0x4b, 0x0a, 0x8a, 0xa1, 0x1d, 0xaa, 0x81, 0x5f, 0x80, 0xad, 0x3e, 0x1b, 0xdd, 0x00, 0xc4,
      } 0xc9, 0x2a, 0x22, 0xe1, 0x97, 0x59, 0x9c, 0xb8, 0x57, 0xe8, 0x0e, 0x6e, 0x49, 0x14, 0x46, 0xf1,
      } 0x72, 0xb5, 0x49, 0xd7, 0x61, 0x18, 0xa5, 0xa9, 0x6b, 0xbc, 0x26, 0x3f, 0xcf, 0xe2, 0xf9, 0x9a,
      wireType := int(wire & 0x7) 0x44, 0xae, 0x89, 0xc6, 0xe0, 0x90, 0xc5, 0x7c, 0xfe, 0x34, 0x0b, 0x9f, 0x5d, 0x0b, 0xdd, 0x83,
      switch wireType { 0xdb, 0x49, 0xce, 0xac, 0xed, 0x4f, 0xc1, 0x09, 0xa9, 0x2c, 0xb7, 0x4c, 0x1c, 0xd1, 0x08, 0x06,
      case 0: 0x24, 0xfa, 0xb6, 0x8e, 0xd2, 0x95, 0x7b, 0xa5, 0xcd, 0x51, 0xba, 0x5c, 0x24, 0x69, 0xe4, 0x1a,
      for shift := uint(0); ; shift += 7 { 0xaa, 0xb4, 0x4e, 0x9e, 0x93, 0xc5, 0xf7, 0xc4, 0x35, 0xfd, 0xd9, 0xf9, 0x39, 0xd4, 0x6b, 0x96,
      if shift >= 64 { 0x75, 0x2e, 0x8e, 0x5c, 0x96, 0x85, 0xde, 0x97, 0x43, 0x2e, 0x84, 0xba, 0x72, 0xce, 0x6a, 0x59,
      return 0, ErrIntOverflowIbtp 0xd6, 0x52, 0x6f, 0x6e, 0x4c, 0x3a, 0xe8, 0xff, 0x31, 0xce, 0x25, 0xf4, 0x16, 0x6e, 0x1b, 0x91,
      } 0x6f, 0x14, 0x14, 0x34, 0x97, 0x9b, 0xaa, 0x38, 0x6d, 0xfe, 0xba, 0x11, 0x79, 0x78, 0x62, 0xe3,
      if iNdEx >= l { 0x42, 0xe9, 0x8a, 0x46, 0xfe, 0xa3, 0x6b, 0xf3, 0x70, 0x5d, 0x34, 0xf2, 0x95, 0x4e, 0xc5, 0xe7,
      return 0, io.ErrUnexpectedEOF 0x50, 0xe7, 0x3a, 0x19, 0x2a, 0x3e, 0x87, 0x3a, 0x57, 0x1c, 0x15, 0xdb, 0x06, 0xdb, 0x9e, 0x15,
      } 0x8c, 0x89, 0x3e, 0xa3, 0x07, 0x70, 0x72, 0xba, 0xdb, 0x65, 0x34, 0xff, 0xa1, 0x83, 0x30, 0x24,
      iNdEx++ 0x67, 0x8c, 0xfe, 0x83, 0xbe, 0xd2, 0x84, 0x19, 0xee, 0x6b, 0xc7, 0x09, 0x29, 0x8f, 0x60, 0x27,
      if dAtA[iNdEx-1] < 0x80 { 0xcf, 0xa0, 0xf5, 0x74, 0xb8, 0xf3, 0x90, 0x0c, 0x3b, 0x17, 0x0f, 0xc9, 0xfc, 0x77, 0xd0, 0x53,
      break 0x21, 0x6c, 0xd0, 0xff, 0xd0, 0x53, 0xf9, 0x6f, 0xb0, 0xe1, 0x59, 0xc1, 0x68, 0xea, 0x74, 0xf1,
      } 0x24, 0x2d, 0xed, 0x3f, 0x42, 0x5f, 0x94, 0xcd, 0x61, 0x27, 0xd5, 0xe7, 0x16, 0x54, 0x52, 0x2d,
      } 0x1c, 0x13, 0x7d, 0xce, 0xfa, 0xfa, 0x2f, 0xf9, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0x4f, 0xb2,
      case 1: 0x54, 0x4d, 0x44, 0x03, 0x00, 0x00,
      iNdEx += 8
      case 2:
      var length int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 0, ErrIntOverflowIbtp
      }
      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, ErrInvalidLengthIbtp
      }
      iNdEx += length
      case 3:
      depth++
      case 4:
      if depth == 0 {
      return 0, ErrUnexpectedEndOfGroupIbtp
      }
      depth--
      case 5:
      iNdEx += 4
      default:
      return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
      if iNdEx < 0 {
      return 0, ErrInvalidLengthIbtp
      }
      if depth == 0 {
      return iNdEx, nil
      }
      }
      return 0, io.ErrUnexpectedEOF
      } }
      var (
      ErrInvalidLengthIbtp = fmt.Errorf("proto: negative length found during unmarshaling")
      ErrIntOverflowIbtp = fmt.Errorf("proto: integer overflow")
      ErrUnexpectedEndOfGroupIbtp = fmt.Errorf("proto: unexpected end of group")
      )
      model/pb/ibtp.proto
      View file @ 3ac49d2d
      ...@@ -61,3 +61,7 @@ message content { ...@@ -61,3 +61,7 @@ message content {
      message IBTPs { message IBTPs {
      repeated IBTP ibtps = 1; repeated IBTP ibtps = 1;
      } }
      message result {
      repeated bytes data = 1;
      }
      Markdown is supported
      0% or
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment