Skip to content

S
sidecar
Commit 04eb4a2e authored by harrylee's avatar harrylee
Browse files
Options

update gogoprotobuf

parent 3ac49d2d
Pipeline #8461 failed with stages
      Hide whitespace changes
      Inline Side-by-side
      Showing with 1586 additions and 232 deletions
      model/pb/basic.pb.go
      View file @ 04eb4a2e
      ......@@ -5,18 +5,15 @@ package pb
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      io "io"
      math "math"
      math_bits "math/bits"
      proto "github.com/gogo/protobuf/proto"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      ......@@ -29,20 +26,15 @@ type Uint64Slice struct {
      Slice []uint64 `protobuf:"varint,1,rep,packed,name=slice,proto3" json:"slice,omitempty"`
      }
      func (m *Uint64Slice) Reset() { *m = Uint64Slice{} }
      func (m *Uint64Slice) Reset() { *m = Uint64Slice{} }
      func (m *Uint64Slice) String() string { return proto.CompactTextString(m) }
      func (*Uint64Slice) ProtoMessage() {}
      func (*Uint64Slice) ProtoMessage() {}
      func (*Uint64Slice) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{0}
      }
      func (m *Uint64Slice) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *Uint64Slice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_Uint64Slice.Marshal(b, m, deterministic)
      ......@@ -55,15 +47,12 @@ func (m *Uint64Slice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
      return b[:n], nil
      }
      }
      func (m *Uint64Slice) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Uint64Slice.Merge(m, src)
      }
      func (m *Uint64Slice) XXX_Size() int {
      return m.Size()
      }
      func (m *Uint64Slice) XXX_DiscardUnknown() {
      xxx_messageInfo_Uint64Slice.DiscardUnknown(m)
      }
      ......@@ -82,20 +71,15 @@ type StringUint64Map struct {
      Vals []uint64 `protobuf:"varint,2,rep,packed,name=vals,proto3" json:"vals,omitempty"`
      }
      func (m *StringUint64Map) Reset() { *m = StringUint64Map{} }
      func (m *StringUint64Map) Reset() { *m = StringUint64Map{} }
      func (m *StringUint64Map) String() string { return proto.CompactTextString(m) }
      func (*StringUint64Map) ProtoMessage() {}
      func (*StringUint64Map) ProtoMessage() {}
      func (*StringUint64Map) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{1}
      }
      func (m *StringUint64Map) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *StringUint64Map) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_StringUint64Map.Marshal(b, m, deterministic)
      ......@@ -108,15 +92,12 @@ func (m *StringUint64Map) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
      return b[:n], nil
      }
      }
      func (m *StringUint64Map) XXX_Merge(src proto.Message) {
      xxx_messageInfo_StringUint64Map.Merge(m, src)
      }
      func (m *StringUint64Map) XXX_Size() int {
      return m.Size()
      }
      func (m *StringUint64Map) XXX_DiscardUnknown() {
      xxx_messageInfo_StringUint64Map.DiscardUnknown(m)
      }
      ......@@ -142,20 +123,15 @@ type StringUint64SliceMap struct {
      Vals []*Uint64Slice `protobuf:"bytes,2,rep,name=vals,proto3" json:"vals,omitempty"`
      }
      func (m *StringUint64SliceMap) Reset() { *m = StringUint64SliceMap{} }
      func (m *StringUint64SliceMap) Reset() { *m = StringUint64SliceMap{} }
      func (m *StringUint64SliceMap) String() string { return proto.CompactTextString(m) }
      func (*StringUint64SliceMap) ProtoMessage() {}
      func (*StringUint64SliceMap) ProtoMessage() {}
      func (*StringUint64SliceMap) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{2}
      }
      func (m *StringUint64SliceMap) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *StringUint64SliceMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_StringUint64SliceMap.Marshal(b, m, deterministic)
      ......@@ -168,15 +144,12 @@ func (m *StringUint64SliceMap) XXX_Marshal(b []byte, deterministic bool) ([]byte
      return b[:n], nil
      }
      }
      func (m *StringUint64SliceMap) XXX_Merge(src proto.Message) {
      xxx_messageInfo_StringUint64SliceMap.Merge(m, src)
      }
      func (m *StringUint64SliceMap) XXX_Size() int {
      return m.Size()
      }
      func (m *StringUint64SliceMap) XXX_DiscardUnknown() {
      xxx_messageInfo_StringUint64SliceMap.DiscardUnknown(m)
      }
      ......@@ -202,20 +175,15 @@ type VerifiedIndex struct {
      Valid bool `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
      }
      func (m *VerifiedIndex) Reset() { *m = VerifiedIndex{} }
      func (m *VerifiedIndex) Reset() { *m = VerifiedIndex{} }
      func (m *VerifiedIndex) String() string { return proto.CompactTextString(m) }
      func (*VerifiedIndex) ProtoMessage() {}
      func (*VerifiedIndex) ProtoMessage() {}
      func (*VerifiedIndex) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{3}
      }
      func (m *VerifiedIndex) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *VerifiedIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_VerifiedIndex.Marshal(b, m, deterministic)
      ......@@ -228,15 +196,12 @@ func (m *VerifiedIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
      return b[:n], nil
      }
      }
      func (m *VerifiedIndex) XXX_Merge(src proto.Message) {
      xxx_messageInfo_VerifiedIndex.Merge(m, src)
      }
      func (m *VerifiedIndex) XXX_Size() int {
      return m.Size()
      }
      func (m *VerifiedIndex) XXX_DiscardUnknown() {
      xxx_messageInfo_VerifiedIndex.DiscardUnknown(m)
      }
      ......@@ -261,20 +226,15 @@ type VerifiedIndexSlice struct {
      Slice []*VerifiedIndex `protobuf:"bytes,1,rep,name=slice,proto3" json:"slice,omitempty"`
      }
      func (m *VerifiedIndexSlice) Reset() { *m = VerifiedIndexSlice{} }
      func (m *VerifiedIndexSlice) Reset() { *m = VerifiedIndexSlice{} }
      func (m *VerifiedIndexSlice) String() string { return proto.CompactTextString(m) }
      func (*VerifiedIndexSlice) ProtoMessage() {}
      func (*VerifiedIndexSlice) ProtoMessage() {}
      func (*VerifiedIndexSlice) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{4}
      }
      func (m *VerifiedIndexSlice) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *VerifiedIndexSlice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_VerifiedIndexSlice.Marshal(b, m, deterministic)
      ......@@ -287,15 +247,12 @@ func (m *VerifiedIndexSlice) XXX_Marshal(b []byte, deterministic bool) ([]byte,
      return b[:n], nil
      }
      }
      func (m *VerifiedIndexSlice) XXX_Merge(src proto.Message) {
      xxx_messageInfo_VerifiedIndexSlice.Merge(m, src)
      }
      func (m *VerifiedIndexSlice) XXX_Size() int {
      return m.Size()
      }
      func (m *VerifiedIndexSlice) XXX_DiscardUnknown() {
      xxx_messageInfo_VerifiedIndexSlice.DiscardUnknown(m)
      }
      ......@@ -314,20 +271,15 @@ type StringVerifiedIndexMap struct {
      Vals []*VerifiedIndex `protobuf:"bytes,2,rep,name=vals,proto3" json:"vals,omitempty"`
      }
      func (m *StringVerifiedIndexMap) Reset() { *m = StringVerifiedIndexMap{} }
      func (m *StringVerifiedIndexMap) Reset() { *m = StringVerifiedIndexMap{} }
      func (m *StringVerifiedIndexMap) String() string { return proto.CompactTextString(m) }
      func (*StringVerifiedIndexMap) ProtoMessage() {}
      func (*StringVerifiedIndexMap) ProtoMessage() {}
      func (*StringVerifiedIndexMap) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{5}
      }
      func (m *StringVerifiedIndexMap) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *StringVerifiedIndexMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_StringVerifiedIndexMap.Marshal(b, m, deterministic)
      ......@@ -340,15 +292,12 @@ func (m *StringVerifiedIndexMap) XXX_Marshal(b []byte, deterministic bool) ([]by
      return b[:n], nil
      }
      }
      func (m *StringVerifiedIndexMap) XXX_Merge(src proto.Message) {
      xxx_messageInfo_StringVerifiedIndexMap.Merge(m, src)
      }
      func (m *StringVerifiedIndexMap) XXX_Size() int {
      return m.Size()
      }
      func (m *StringVerifiedIndexMap) XXX_DiscardUnknown() {
      xxx_messageInfo_StringVerifiedIndexMap.DiscardUnknown(m)
      }
      ......@@ -374,20 +323,15 @@ type StringVerifiedIndexSliceMap struct {
      Vals []*VerifiedIndexSlice `protobuf:"bytes,2,rep,name=vals,proto3" json:"vals,omitempty"`
      }
      func (m *StringVerifiedIndexSliceMap) Reset() { *m = StringVerifiedIndexSliceMap{} }
      func (m *StringVerifiedIndexSliceMap) Reset() { *m = StringVerifiedIndexSliceMap{} }
      func (m *StringVerifiedIndexSliceMap) String() string { return proto.CompactTextString(m) }
      func (*StringVerifiedIndexSliceMap) ProtoMessage() {}
      func (*StringVerifiedIndexSliceMap) ProtoMessage() {}
      func (*StringVerifiedIndexSliceMap) Descriptor() ([]byte, []int) {
      return fileDescriptor_0cc45f6ac745dd88, []int{6}
      }
      func (m *StringVerifiedIndexSliceMap) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *StringVerifiedIndexSliceMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_StringVerifiedIndexSliceMap.Marshal(b, m, deterministic)
      ......@@ -400,15 +344,12 @@ func (m *StringVerifiedIndexSliceMap) XXX_Marshal(b []byte, deterministic bool)
      return b[:n], nil
      }
      }
      func (m *StringVerifiedIndexSliceMap) XXX_Merge(src proto.Message) {
      xxx_messageInfo_StringVerifiedIndexSliceMap.Merge(m, src)
      }
      func (m *StringVerifiedIndexSliceMap) XXX_Size() int {
      return m.Size()
      }
      func (m *StringVerifiedIndexSliceMap) XXX_DiscardUnknown() {
      xxx_messageInfo_StringVerifiedIndexSliceMap.DiscardUnknown(m)
      }
      ......@@ -777,7 +718,6 @@ func encodeVarintBasic(dAtA []byte, offset int, v uint64) int {
      dAtA[offset] = uint8(v)
      return base
      }
      func (m *Uint64Slice) Size() (n int) {
      if m == nil {
      return 0
      ......@@ -912,11 +852,9 @@ func (m *StringVerifiedIndexSliceMap) Size() (n int) {
      func sovBasic(x uint64) (n int) {
      return (math_bits.Len64(x|1) + 6) / 7
      }
      func sozBasic(x uint64) (n int) {
      return sovBasic(uint64((x << 1) ^ uint64((int64(x) >> 63))))
      }
      func (m *Uint64Slice) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1043,7 +981,6 @@ func (m *Uint64Slice) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *StringUint64Map) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1202,7 +1139,6 @@ func (m *StringUint64Map) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *StringUint64SliceMap) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1319,7 +1255,6 @@ func (m *StringUint64SliceMap) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *VerifiedIndex) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1409,7 +1344,6 @@ func (m *VerifiedIndex) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *VerifiedIndexSlice) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1494,7 +1428,6 @@ func (m *VerifiedIndexSlice) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *StringVerifiedIndexMap) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1611,7 +1544,6 @@ func (m *StringVerifiedIndexMap) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *StringVerifiedIndexSliceMap) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -1728,7 +1660,6 @@ func (m *StringVerifiedIndexSliceMap) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func skipBasic(dAtA []byte) (n int, err error) {
      l := len(dAtA)
      iNdEx := 0
      ......
      model/pb/ibtp.pb.go
      View file @ 04eb4a2e
      // Code generated by protoc-gen-go. DO NOT EDIT.
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ibtp.proto
      package pb
      import (
      fmt "fmt"
      proto "github.com/golang/protobuf/proto"
      proto "github.com/gogo/protobuf/proto"
      io "io"
      math "math"
      math_bits "math/bits"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      ......@@ -18,7 +20,7 @@ var _ = math.Inf
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type IBTP_Type int32
      ......@@ -103,10 +105,7 @@ type IBTP struct {
      // Message version
      Version string `protobuf:"bytes,9,opt,name=version,proto3" json:"version,omitempty"`
      // Self-defined fields used by app-chain
      Extra []byte `protobuf:"bytes,10,opt,name=extra,proto3" json:"extra,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      Extra []byte `protobuf:"bytes,10,opt,name=extra,proto3" json:"extra,omitempty"`
      }
      func (m *IBTP) Reset() { *m = IBTP{} }
      ......@@ -115,18 +114,26 @@ func (*IBTP) ProtoMessage() {}
      func (*IBTP) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{0}
      }
      func (m *IBTP) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_IBTP.Unmarshal(m, b)
      return m.Unmarshal(b)
      }
      func (m *IBTP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_IBTP.Marshal(b, m, deterministic)
      if 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) {
      xxx_messageInfo_IBTP.Merge(m, src)
      }
      func (m *IBTP) XXX_Size() int {
      return xxx_messageInfo_IBTP.Size(m)
      return m.Size()
      }
      func (m *IBTP) XXX_DiscardUnknown() {
      xxx_messageInfo_IBTP.DiscardUnknown(m)
      ......@@ -205,11 +212,8 @@ func (m *IBTP) GetExtra() []byte {
      }
      type Payload struct {
      Encrypted bool `protobuf:"varint,1,opt,name=encrypted,proto3" json:"encrypted,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:"-"`
      Encrypted bool `protobuf:"varint,1,opt,name=encrypted,proto3" json:"encrypted,omitempty"`
      Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
      }
      func (m *Payload) Reset() { *m = Payload{} }
      ......@@ -218,18 +222,26 @@ func (*Payload) ProtoMessage() {}
      func (*Payload) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{1}
      }
      func (m *Payload) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Payload.Unmarshal(m, b)
      return m.Unmarshal(b)
      }
      func (m *Payload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Payload.Marshal(b, m, deterministic)
      if 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) {
      xxx_messageInfo_Payload.Merge(m, src)
      }
      func (m *Payload) XXX_Size() int {
      return xxx_messageInfo_Payload.Size(m)
      return m.Size()
      }
      func (m *Payload) XXX_DiscardUnknown() {
      xxx_messageInfo_Payload.DiscardUnknown(m)
      ......@@ -252,17 +264,14 @@ func (m *Payload) GetContent() []byte {
      }
      type Content struct {
      SrcContractId string `protobuf:"bytes,1,opt,name=src_contract_id,json=srcContractId,proto3" json:"src_contract_id,omitempty"`
      DstContractId string `protobuf:"bytes,2,opt,name=dst_contract_id,json=dstContractId,proto3" json:"dst_contract_id,omitempty"`
      Func string `protobuf:"bytes,3,opt,name=func,proto3" json:"func,omitempty"`
      Args [][]byte `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
      Callback string `protobuf:"bytes,5,opt,name=callback,proto3" json:"callback,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"`
      ArgsRb [][]byte `protobuf:"bytes,8,rep,name=argsRb,proto3" json:"argsRb,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      SrcContractId string `protobuf:"bytes,1,opt,name=src_contract_id,json=srcContractId,proto3" json:"src_contract_id,omitempty"`
      DstContractId string `protobuf:"bytes,2,opt,name=dst_contract_id,json=dstContractId,proto3" json:"dst_contract_id,omitempty"`
      Func string `protobuf:"bytes,3,opt,name=func,proto3" json:"func,omitempty"`
      Args [][]byte `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
      Callback string `protobuf:"bytes,5,opt,name=callback,proto3" json:"callback,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"`
      ArgsRb [][]byte `protobuf:"bytes,8,rep,name=argsRb,proto3" json:"argsRb,omitempty"`
      }
      func (m *Content) Reset() { *m = Content{} }
      ......@@ -271,18 +280,26 @@ func (*Content) ProtoMessage() {}
      func (*Content) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{2}
      }
      func (m *Content) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Content.Unmarshal(m, b)
      return m.Unmarshal(b)
      }
      func (m *Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Content.Marshal(b, m, deterministic)
      if 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) {
      xxx_messageInfo_Content.Merge(m, src)
      }
      func (m *Content) XXX_Size() int {
      return xxx_messageInfo_Content.Size(m)
      return m.Size()
      }
      func (m *Content) XXX_DiscardUnknown() {
      xxx_messageInfo_Content.DiscardUnknown(m)
      ......@@ -347,10 +364,7 @@ func (m *Content) GetArgsRb() [][]byte {
      }
      type IBTPs struct {
      Ibtps []*IBTP `protobuf:"bytes,1,rep,name=ibtps,proto3" json:"ibtps,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      Ibtps []*IBTP `protobuf:"bytes,1,rep,name=ibtps,proto3" json:"ibtps,omitempty"`
      }
      func (m *IBTPs) Reset() { *m = IBTPs{} }
      ......@@ -359,18 +373,26 @@ func (*IBTPs) ProtoMessage() {}
      func (*IBTPs) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{3}
      }
      func (m *IBTPs) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_IBTPs.Unmarshal(m, b)
      return m.Unmarshal(b)
      }
      func (m *IBTPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_IBTPs.Marshal(b, m, deterministic)
      if 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) {
      xxx_messageInfo_IBTPs.Merge(m, src)
      }
      func (m *IBTPs) XXX_Size() int {
      return xxx_messageInfo_IBTPs.Size(m)
      return m.Size()
      }
      func (m *IBTPs) XXX_DiscardUnknown() {
      xxx_messageInfo_IBTPs.DiscardUnknown(m)
      ......@@ -386,10 +408,7 @@ func (m *IBTPs) GetIbtps() []*IBTP {
      }
      type Result struct {
      Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
      }
      func (m *Result) Reset() { *m = Result{} }
      ......@@ -398,18 +417,26 @@ func (*Result) ProtoMessage() {}
      func (*Result) Descriptor() ([]byte, []int) {
      return fileDescriptor_7576a0a5bf0190a3, []int{4}
      }
      func (m *Result) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Result.Unmarshal(m, b)
      return m.Unmarshal(b)
      }
      func (m *Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Result.Marshal(b, m, deterministic)
      if deterministic {
      return xxx_messageInfo_Result.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 *Result) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Result.Merge(m, src)
      }
      func (m *Result) XXX_Size() int {
      return xxx_messageInfo_Result.Size(m)
      return m.Size()
      }
      func (m *Result) XXX_DiscardUnknown() {
      xxx_messageInfo_Result.DiscardUnknown(m)
      ......@@ -434,44 +461,1488 @@ func init() {
      proto.RegisterType((*Result)(nil), "pb.result")
      }
      func init() {
      proto.RegisterFile("ibtp.proto", fileDescriptor_7576a0a5bf0190a3)
      }
      func init() { proto.RegisterFile("ibtp.proto", fileDescriptor_7576a0a5bf0190a3) }
      var fileDescriptor_7576a0a5bf0190a3 = []byte{
      // 534 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x53, 0xcd, 0x8e, 0xda, 0x3c,
      0x14, 0x9d, 0xfc, 0x00, 0xe1, 0xc2, 0xcc, 0x44, 0x9e, 0xd1, 0x27, 0x6b, 0x34, 0xfa, 0x94, 0x66,
      0xd1, 0xa6, 0x1b, 0x16, 0xb4, 0xea, 0x9e, 0x89, 0x52, 0x35, 0x1a, 0x1a, 0xa8, 0x03, 0xea, 0x12,
      0x39, 0x3f, 0x83, 0xa2, 0x42, 0x6c, 0x39, 0xa6, 0x2a, 0x2f, 0xd4, 0x77, 0xeb, 0x5b, 0x54, 0x76,
      0x08, 0x4c, 0x77, 0x3e, 0xe7, 0x9e, 0x73, 0x6f, 0xec, 0x7b, 0x02, 0x50, 0x65, 0x92, 0x4f, 0xb8,
      0x60, 0x92, 0x21, 0x93, 0x67, 0x0f, 0xa3, 0x8c, 0x36, 0x55, 0xde, 0x12, 0xfe, 0x6f, 0x0b, 0xec,
      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,
      0xe5, 0x19, 0x81, 0x4d, 0x5a, 0x80, 0xde, 0x80, 0x2d, 0x8f, 0xbc, 0xc4, 0xb6, 0x67, 0x04, 0x37,
      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,
      0x18, 0x7b, 0xc1, 0x7d, 0xcf, 0x08, 0xc6, 0xa4, 0x05, 0x08, 0xc3, 0x80, 0xd3, 0xe3, 0x8e, 0xd1,
      0x02, 0x0f, 0x34, 0xdf, 0x41, 0xf4, 0x1e, 0x7a, 0x5b, 0xc1, 0x0e, 0x1c, 0x3b, 0x9e, 0x11, 0x8c,
      0xa6, 0x77, 0x6a, 0x62, 0x2a, 0x45, 0x55, 0x6f, 0xd7, 0x55, 0x2d, 0x3f, 0x7d, 0xfc, 0x4a, 0x39,
      0x69, 0x15, 0xaa, 0xc9, 0xcf, 0x52, 0x34, 0x15, 0xab, 0xf1, 0x50, 0x5f, 0xa3, 0x83, 0x6a, 0x68,
      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,
      0x44, 0xae, 0x89, 0xc6, 0xe0, 0x90, 0xc5, 0x7c, 0xfe, 0x34, 0x0b, 0x9f, 0x5d, 0x0b, 0xdd, 0x83,
      0xdb, 0x49, 0xce, 0xac, 0xed, 0x4f, 0xc1, 0x09, 0xa9, 0x2c, 0xb7, 0x4c, 0x1c, 0xd1, 0x08, 0x06,
      0x24, 0xfa, 0xb6, 0x8e, 0xd2, 0x95, 0x7b, 0xa5, 0xcd, 0x51, 0xba, 0x5c, 0x24, 0x69, 0xe4, 0x1a,
      0xaa, 0xb4, 0x4e, 0x9e, 0x93, 0xc5, 0xf7, 0xc4, 0x35, 0xfd, 0xd9, 0xf9, 0x39, 0xd4, 0x6b, 0x96,
      0x75, 0x2e, 0x8e, 0x5c, 0x96, 0x85, 0xde, 0x97, 0x43, 0x2e, 0x84, 0xba, 0x72, 0xce, 0x6a, 0x59,
      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,
      0x42, 0xe9, 0x8a, 0x46, 0xfe, 0xa3, 0x6b, 0xf3, 0x70, 0x5d, 0x34, 0xf2, 0x95, 0x4e, 0xc5, 0xe7,
      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,
      0x67, 0x8c, 0xfe, 0x83, 0xbe, 0xd2, 0x84, 0x19, 0xee, 0x6b, 0xc7, 0x09, 0x29, 0x8f, 0x60, 0x27,
      0xcf, 0xa0, 0xf5, 0x74, 0xb8, 0xf3, 0x90, 0x0c, 0x3b, 0x17, 0x0f, 0xc9, 0xfc, 0x77, 0xd0, 0x53,
      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,
      0x54, 0x4d, 0x44, 0x03, 0x00, 0x00,
      // 568 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x53, 0x4d, 0x6f, 0xd3, 0x40,
      0x10, 0xcd, 0x26, 0x4e, 0xe2, 0x4c, 0xd2, 0xd6, 0xda, 0x56, 0x68, 0x55, 0x55, 0x96, 0xf1, 0x01,
      0xcc, 0x25, 0x87, 0x80, 0xb8, 0xa7, 0x96, 0x11, 0x51, 0x4b, 0x5a, 0xd6, 0x89, 0x38, 0x56, 0xeb,
      0x8f, 0x46, 0x16, 0xa9, 0x77, 0xb5, 0xde, 0x20, 0xf2, 0x2f, 0xf8, 0x15, 0xfc, 0x16, 0x8e, 0x3d,
      0x72, 0x44, 0xed, 0x89, 0x7f, 0x81, 0x76, 0x1d, 0xa7, 0xe5, 0xb6, 0xef, 0xcd, 0x7b, 0x33, 0xde,
      0x9d, 0x67, 0x80, 0x22, 0x51, 0x62, 0x2c, 0x24, 0x57, 0x1c, 0xb7, 0x45, 0x72, 0x3a, 0x4c, 0x58,
      0x55, 0xa4, 0x35, 0xe1, 0xff, 0xec, 0x80, 0x35, 0x3b, 0x5f, 0x5c, 0x63, 0x0c, 0xd6, 0xad, 0xe4,
      0x77, 0x04, 0x79, 0x28, 0x18, 0x50, 0x73, 0xc6, 0x87, 0xd0, 0x56, 0x9c, 0xb4, 0x0d, 0xd3, 0x56,
      0x1c, 0x9f, 0x40, 0xb7, 0xe4, 0x65, 0x9a, 0x93, 0x8e, 0x87, 0x02, 0x8b, 0xd6, 0x00, 0xbf, 0x04,
      0x4b, 0x6d, 0x45, 0x4e, 0x2c, 0x0f, 0x05, 0x87, 0x93, 0x83, 0xb1, 0x48, 0xc6, 0xba, 0xe3, 0x78,
      0xb1, 0x15, 0x39, 0x35, 0x25, 0x7c, 0x06, 0x03, 0x55, 0xdc, 0xe5, 0x95, 0x62, 0x77, 0x82, 0x74,
      0x3d, 0x14, 0x74, 0xe8, 0x13, 0xa1, 0xdb, 0x0a, 0xc9, 0xf9, 0x2d, 0xe9, 0x79, 0x28, 0x18, 0xd1,
      0x1a, 0x60, 0x02, 0x7d, 0xc1, 0xb6, 0x6b, 0xce, 0x32, 0xd2, 0x37, 0x7c, 0x03, 0xf1, 0x1b, 0xe8,
      0xae, 0x24, 0xdf, 0x08, 0x62, 0x7b, 0x28, 0x18, 0x4e, 0x8e, 0xf5, 0xc4, 0x58, 0xc9, 0xa2, 0x5c,
      0x2d, 0x8b, 0x52, 0xbd, 0x7f, 0xf7, 0x89, 0x09, 0x5a, 0x2b, 0x74, 0x93, 0x6f, 0xb9, 0xac, 0x0a,
      0x5e, 0x92, 0x81, 0xb9, 0x46, 0x03, 0xf5, 0xd0, 0xfc, 0xbb, 0x92, 0x8c, 0x40, 0x3d, 0xd4, 0x00,
      0x3f, 0x03, 0x4b, 0x7f, 0x36, 0x3e, 0x04, 0x98, 0xcd, 0x17, 0x11, 0x0d, 0x3f, 0x4e, 0x67, 0x73,
      0xa7, 0x85, 0x8f, 0xe1, 0x88, 0x46, 0x61, 0x34, 0xbb, 0x5e, 0xdc, 0xc4, 0xcb, 0x30, 0x8c, 0xe2,
      0xd8, 0x41, 0xcf, 0xc9, 0x0f, 0xd3, 0xd9, 0xe5, 0x92, 0x46, 0x4e, 0x1b, 0x8f, 0xc0, 0xa6, 0x57,
      0x97, 0x97, 0xe7, 0xd3, 0xf0, 0xc2, 0xe9, 0xe0, 0x13, 0x70, 0x1a, 0xc9, 0x9e, 0xb5, 0xfc, 0x09,
      0xd8, 0x21, 0x53, 0xf9, 0x8a, 0xcb, 0x2d, 0x1e, 0x42, 0x9f, 0x46, 0x9f, 0x97, 0x51, 0xbc, 0x70,
      0x5a, 0xc6, 0x1c, 0xc5, 0xd7, 0x57, 0xf3, 0x38, 0x72, 0x90, 0x2e, 0x2d, 0xe7, 0x17, 0xf3, 0xab,
      0x2f, 0x73, 0xa7, 0xed, 0x4f, 0xf7, 0xcf, 0xa1, 0x5f, 0x33, 0x2f, 0x53, 0xb9, 0x15, 0x2a, 0xcf,
      0xcc, 0xbe, 0x6c, 0xfa, 0x44, 0xe8, 0x2b, 0xa7, 0xbc, 0x54, 0x79, 0xa9, 0xcc, 0xe6, 0x46, 0xb4,
      0x81, 0xfe, 0x5f, 0xb4, 0x2f, 0xe1, 0x57, 0x70, 0x54, 0xc9, 0xf4, 0x46, 0x43, 0xc9, 0x52, 0x75,
      0x53, 0x64, 0xbb, 0xcd, 0x1f, 0x54, 0x32, 0x0d, 0x77, 0xec, 0x2c, 0xd3, 0xba, 0xac, 0x52, 0xff,
      0xe9, 0xea, 0x3c, 0x1c, 0x64, 0x95, 0x7a, 0xa6, 0xd3, 0xf1, 0xd9, 0x94, 0xa9, 0x49, 0x86, 0x8e,
      0xcf, 0xa6, 0x4c, 0x35, 0xc7, 0xe4, 0xaa, 0x22, 0x96, 0xd7, 0x09, 0x46, 0xd4, 0x9c, 0xf1, 0x29,
      0xd8, 0x29, 0x5b, 0xaf, 0x13, 0x96, 0x7e, 0x35, 0x41, 0x18, 0xd0, 0x3d, 0xc6, 0x2f, 0xa0, 0xa7,
      0x35, 0x61, 0x42, 0x7a, 0xc6, 0xb1, 0x43, 0xda, 0x23, 0xf9, 0xce, 0xd3, 0xaf, 0x3d, 0x0d, 0x6e,
      0x3c, 0x34, 0x21, 0xf6, 0x93, 0x87, 0x26, 0xfe, 0x6b, 0xe8, 0xea, 0x10, 0x56, 0xd8, 0x85, 0xae,
      0xce, 0x7f, 0x45, 0x90, 0xd7, 0x09, 0x86, 0x13, 0xbb, 0x89, 0x27, 0xad, 0x69, 0xff, 0x0c, 0x7a,
      0x32, 0xaf, 0x36, 0x6b, 0xa5, 0x3f, 0x37, 0x63, 0x8a, 0x19, 0xe1, 0x88, 0x9a, 0xf3, 0x39, 0xf9,
      0xf5, 0xe0, 0xa2, 0xfb, 0x07, 0x17, 0xfd, 0x79, 0x70, 0xd1, 0x8f, 0x47, 0xb7, 0x75, 0xff, 0xe8,
      0xb6, 0x7e, 0x3f, 0xba, 0xad, 0xa4, 0x67, 0xfe, 0x9f, 0xb7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff,
      0x95, 0x9e, 0xd1, 0xb1, 0x5e, 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 (m *Result) 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 *Result) MarshalTo(dAtA []byte) (int, error) {
      size := m.Size()
      return m.MarshalToSizedBuffer(dAtA[:size])
      }
      func (m *Result) MarshalToSizedBuffer(dAtA []byte) (int, error) {
      i := len(dAtA)
      _ = i
      var l int
      _ = l
      if len(m.Data) > 0 {
      for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
      i -= len(m.Data[iNdEx])
      copy(dAtA[i:], m.Data[iNdEx])
      i = encodeVarintIbtp(dAtA, i, uint64(len(m.Data[iNdEx])))
      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) {
      if m == nil {
      return 0
      }
      var l int
      _ = 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) {
      if m == nil {
      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 *IBTPs) Size() (n int) {
      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) Size() (n int) {
      if m == nil {
      return 0
      }
      var l int
      _ = l
      if len(m.Data) > 0 {
      for _, b := range m.Data {
      l = len(b)
      n += 1 + l + sovIbtp(uint64(l))
      }
      }
      return n
      }
      func sovIbtp(x uint64) (n int) {
      return (math_bits.Len64(x|1) + 6) / 7
      }
      func sozIbtp(x uint64) (n int) {
      return sovIbtp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
      }
      func (m *IBTP) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 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 {
      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 {
      return io.ErrUnexpectedEOF
      }
      return nil
      }
      func (m *Content) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 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 {
      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: 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 (m *Result) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 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: result: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
      return fmt.Errorf("proto: result: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
      if wireType != 2 {
      return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data = append(m.Data, make([]byte, postIndex-iNdEx))
      copy(m.Data[len(m.Data)-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 skipIbtp(dAtA []byte) (n int, err error) {
      l := len(dAtA)
      iNdEx := 0
      depth := 0
      for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 0, ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return 0, io.ErrUnexpectedEOF
      }
      b := dAtA[iNdEx]
      iNdEx++
      wire |= (uint64(b) & 0x7F) << shift
      if b < 0x80 {
      break
      }
      }
      wireType := int(wire & 0x7)
      switch wireType {
      case 0:
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 0, ErrIntOverflowIbtp
      }
      if iNdEx >= l {
      return 0, io.ErrUnexpectedEOF
      }
      iNdEx++
      if dAtA[iNdEx-1] < 0x80 {
      break
      }
      }
      case 1:
      iNdEx += 8
      case 2:
      var length int
      for shift := uint(0); ; shift += 7 {
      if shift >= 64 {
      return 0, 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/ibtpx.pb.go
      View file @ 04eb4a2e
      ......@@ -5,18 +5,15 @@ package pb
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      io "io"
      math "math"
      math_bits "math/bits"
      proto "github.com/gogo/protobuf/proto"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      ......@@ -37,20 +34,15 @@ type IBTPX struct {
      Count int32 `protobuf:"varint,7,opt,name=count,proto3" json:"count,omitempty"`
      }
      func (m *IBTPX) Reset() { *m = IBTPX{} }
      func (m *IBTPX) Reset() { *m = IBTPX{} }
      func (m *IBTPX) String() string { return proto.CompactTextString(m) }
      func (*IBTPX) ProtoMessage() {}
      func (*IBTPX) ProtoMessage() {}
      func (*IBTPX) Descriptor() ([]byte, []int) {
      return fileDescriptor_8402d80e061d514a, []int{0}
      }
      func (m *IBTPX) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *IBTPX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_IBTPX.Marshal(b, m, deterministic)
      ......@@ -63,15 +55,12 @@ func (m *IBTPX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return b[:n], nil
      }
      }
      func (m *IBTPX) XXX_Merge(src proto.Message) {
      xxx_messageInfo_IBTPX.Merge(m, src)
      }
      func (m *IBTPX) XXX_Size() int {
      return m.Size()
      }
      func (m *IBTPX) XXX_DiscardUnknown() {
      xxx_messageInfo_IBTPX.DiscardUnknown(m)
      }
      ......@@ -244,7 +233,6 @@ func encodeVarintIbtpx(dAtA []byte, offset int, v uint64) int {
      dAtA[offset] = uint8(v)
      return base
      }
      func (m *IBTPX) Size() (n int) {
      if m == nil {
      return 0
      ......@@ -287,11 +275,9 @@ func (m *IBTPX) Size() (n int) {
      func sovIbtpx(x uint64) (n int) {
      return (math_bits.Len64(x|1) + 6) / 7
      }
      func sozIbtpx(x uint64) (n int) {
      return sovIbtpx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
      }
      func (m *IBTPX) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -545,7 +531,6 @@ func (m *IBTPX) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func skipIbtpx(dAtA []byte) (n int, err error) {
      l := len(dAtA)
      iNdEx := 0
      ......
      model/pb/message.pb.go
      View file @ 04eb4a2e
      ......@@ -5,18 +5,15 @@ package pb
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      io "io"
      math "math"
      math_bits "math/bits"
      proto "github.com/gogo/protobuf/proto"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      ......@@ -35,7 +32,7 @@ const (
      Message_APPCHAIN_GET Message_Type = 4
      Message_INTERCHAIN_META_GET Message_Type = 5
      Message_RULE_DEPLOY Message_Type = 6
      // 异步完成
      //异步完成
      Message_IBTP_GET Message_Type = 7
      Message_IBTP_SEND Message_Type = 8
      Message_IBTP_RECEIPT_SEND Message_Type = 9
      ......@@ -87,20 +84,15 @@ type Message struct {
      Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
      }
      func (m *Message) Reset() { *m = Message{} }
      func (m *Message) Reset() { *m = Message{} }
      func (m *Message) String() string { return proto.CompactTextString(m) }
      func (*Message) ProtoMessage() {}
      func (*Message) ProtoMessage() {}
      func (*Message) Descriptor() ([]byte, []int) {
      return fileDescriptor_33c57e4bae7b9afd, []int{0}
      }
      func (m *Message) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_Message.Marshal(b, m, deterministic)
      ......@@ -113,15 +105,12 @@ func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return b[:n], nil
      }
      }
      func (m *Message) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Message.Merge(m, src)
      }
      func (m *Message) XXX_Size() int {
      return m.Size()
      }
      func (m *Message) XXX_DiscardUnknown() {
      xxx_messageInfo_Message.DiscardUnknown(m)
      }
      ......@@ -154,20 +143,15 @@ type Pack struct {
      Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
      }
      func (m *Pack) Reset() { *m = Pack{} }
      func (m *Pack) Reset() { *m = Pack{} }
      func (m *Pack) String() string { return proto.CompactTextString(m) }
      func (*Pack) ProtoMessage() {}
      func (*Pack) ProtoMessage() {}
      func (*Pack) Descriptor() ([]byte, []int) {
      return fileDescriptor_33c57e4bae7b9afd, []int{1}
      }
      func (m *Pack) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *Pack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_Pack.Marshal(b, m, deterministic)
      ......@@ -180,15 +164,12 @@ func (m *Pack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return b[:n], nil
      }
      }
      func (m *Pack) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Pack.Merge(m, src)
      }
      func (m *Pack) XXX_Size() int {
      return m.Size()
      }
      func (m *Pack) XXX_DiscardUnknown() {
      xxx_messageInfo_Pack.DiscardUnknown(m)
      }
      ......@@ -214,20 +195,15 @@ type PeerInfo struct {
      Tag string `protobuf:"bytes,2,opt,name=Tag,proto3" json:"Tag,omitempty"`
      }
      func (m *PeerInfo) Reset() { *m = PeerInfo{} }
      func (m *PeerInfo) Reset() { *m = PeerInfo{} }
      func (m *PeerInfo) String() string { return proto.CompactTextString(m) }
      func (*PeerInfo) ProtoMessage() {}
      func (*PeerInfo) ProtoMessage() {}
      func (*PeerInfo) Descriptor() ([]byte, []int) {
      return fileDescriptor_33c57e4bae7b9afd, []int{2}
      }
      func (m *PeerInfo) XXX_Unmarshal(b []byte) error {
      return m.Unmarshal(b)
      }
      func (m *PeerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      if deterministic {
      return xxx_messageInfo_PeerInfo.Marshal(b, m, deterministic)
      ......@@ -240,15 +216,12 @@ func (m *PeerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return b[:n], nil
      }
      }
      func (m *PeerInfo) XXX_Merge(src proto.Message) {
      xxx_messageInfo_PeerInfo.Merge(m, src)
      }
      func (m *PeerInfo) XXX_Size() int {
      return m.Size()
      }
      func (m *PeerInfo) XXX_DiscardUnknown() {
      xxx_messageInfo_PeerInfo.DiscardUnknown(m)
      }
      ......@@ -441,7 +414,6 @@ func encodeVarintMessage(dAtA []byte, offset int, v uint64) int {
      dAtA[offset] = uint8(v)
      return base
      }
      func (m *Message) Size() (n int) {
      if m == nil {
      return 0
      ......@@ -498,11 +470,9 @@ func (m *PeerInfo) Size() (n int) {
      func sovMessage(x uint64) (n int) {
      return (math_bits.Len64(x|1) + 6) / 7
      }
      func sozMessage(x uint64) (n int) {
      return sovMessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
      }
      func (m *Message) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -640,7 +610,6 @@ func (m *Message) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *Pack) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -745,7 +714,6 @@ func (m *Pack) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func (m *PeerInfo) Unmarshal(dAtA []byte) error {
      l := len(dAtA)
      iNdEx := 0
      ......@@ -860,7 +828,6 @@ func (m *PeerInfo) Unmarshal(dAtA []byte) error {
      }
      return nil
      }
      func skipMessage(dAtA []byte) (n int, err error) {
      l := len(dAtA)
      iNdEx := 0
      ......
      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