// Code generated by protoc-gen-go.
// source: chaincode.proto
// DO NOT EDIT!

package protos

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/ptypes/timestamp"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// Confidentiality Levels
type ConfidentialityLevel int32

const (
	ConfidentialityLevel_PUBLIC       ConfidentialityLevel = 0
	ConfidentialityLevel_CONFIDENTIAL ConfidentialityLevel = 1
)

var ConfidentialityLevel_name = map[int32]string{
	0: "PUBLIC",
	1: "CONFIDENTIAL",
}
var ConfidentialityLevel_value = map[string]int32{
	"PUBLIC":       0,
	"CONFIDENTIAL": 1,
}

func (x ConfidentialityLevel) String() string {
	return proto.EnumName(ConfidentialityLevel_name, int32(x))
}
func (ConfidentialityLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }

type ChaincodeSpec_Type int32

const (
	ChaincodeSpec_UNDEFINED ChaincodeSpec_Type = 0
	ChaincodeSpec_GOLANG    ChaincodeSpec_Type = 1
	ChaincodeSpec_NODE      ChaincodeSpec_Type = 2
	ChaincodeSpec_CAR       ChaincodeSpec_Type = 3
	ChaincodeSpec_JAVA      ChaincodeSpec_Type = 4
)

var ChaincodeSpec_Type_name = map[int32]string{
	0: "UNDEFINED",
	1: "GOLANG",
	2: "NODE",
	3: "CAR",
	4: "JAVA",
}
var ChaincodeSpec_Type_value = map[string]int32{
	"UNDEFINED": 0,
	"GOLANG":    1,
	"NODE":      2,
	"CAR":       3,
	"JAVA":      4,
}

func (x ChaincodeSpec_Type) String() string {
	return proto.EnumName(ChaincodeSpec_Type_name, int32(x))
}
func (ChaincodeSpec_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{2, 0} }

type ChaincodeDeploymentSpec_ExecutionEnvironment int32

const (
	ChaincodeDeploymentSpec_DOCKER ChaincodeDeploymentSpec_ExecutionEnvironment = 0
	ChaincodeDeploymentSpec_SYSTEM ChaincodeDeploymentSpec_ExecutionEnvironment = 1
)

var ChaincodeDeploymentSpec_ExecutionEnvironment_name = map[int32]string{
	0: "DOCKER",
	1: "SYSTEM",
}
var ChaincodeDeploymentSpec_ExecutionEnvironment_value = map[string]int32{
	"DOCKER": 0,
	"SYSTEM": 1,
}

func (x ChaincodeDeploymentSpec_ExecutionEnvironment) String() string {
	return proto.EnumName(ChaincodeDeploymentSpec_ExecutionEnvironment_name, int32(x))
}
func (ChaincodeDeploymentSpec_ExecutionEnvironment) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor2, []int{3, 0}
}

type ChaincodeMessage_Type int32

const (
	ChaincodeMessage_UNDEFINED               ChaincodeMessage_Type = 0
	ChaincodeMessage_REGISTER                ChaincodeMessage_Type = 1
	ChaincodeMessage_REGISTERED              ChaincodeMessage_Type = 2
	ChaincodeMessage_INIT                    ChaincodeMessage_Type = 3
	ChaincodeMessage_READY                   ChaincodeMessage_Type = 4
	ChaincodeMessage_TRANSACTION             ChaincodeMessage_Type = 5
	ChaincodeMessage_COMPLETED               ChaincodeMessage_Type = 6
	ChaincodeMessage_ERROR                   ChaincodeMessage_Type = 7
	ChaincodeMessage_GET_STATE               ChaincodeMessage_Type = 8
	ChaincodeMessage_PUT_STATE               ChaincodeMessage_Type = 9
	ChaincodeMessage_DEL_STATE               ChaincodeMessage_Type = 10
	ChaincodeMessage_INVOKE_CHAINCODE        ChaincodeMessage_Type = 11
	ChaincodeMessage_INVOKE_QUERY            ChaincodeMessage_Type = 12
	ChaincodeMessage_RESPONSE                ChaincodeMessage_Type = 13
	ChaincodeMessage_QUERY                   ChaincodeMessage_Type = 14
	ChaincodeMessage_QUERY_COMPLETED         ChaincodeMessage_Type = 15
	ChaincodeMessage_QUERY_ERROR             ChaincodeMessage_Type = 16
	ChaincodeMessage_RANGE_QUERY_STATE       ChaincodeMessage_Type = 17
	ChaincodeMessage_RANGE_QUERY_STATE_NEXT  ChaincodeMessage_Type = 18
	ChaincodeMessage_RANGE_QUERY_STATE_CLOSE ChaincodeMessage_Type = 19
	ChaincodeMessage_KEEPALIVE               ChaincodeMessage_Type = 20
)

var ChaincodeMessage_Type_name = map[int32]string{
	0:  "UNDEFINED",
	1:  "REGISTER",
	2:  "REGISTERED",
	3:  "INIT",
	4:  "READY",
	5:  "TRANSACTION",
	6:  "COMPLETED",
	7:  "ERROR",
	8:  "GET_STATE",
	9:  "PUT_STATE",
	10: "DEL_STATE",
	11: "INVOKE_CHAINCODE",
	12: "INVOKE_QUERY",
	13: "RESPONSE",
	14: "QUERY",
	15: "QUERY_COMPLETED",
	16: "QUERY_ERROR",
	17: "RANGE_QUERY_STATE",
	18: "RANGE_QUERY_STATE_NEXT",
	19: "RANGE_QUERY_STATE_CLOSE",
	20: "KEEPALIVE",
}
var ChaincodeMessage_Type_value = map[string]int32{
	"UNDEFINED":               0,
	"REGISTER":                1,
	"REGISTERED":              2,
	"INIT":                    3,
	"READY":                   4,
	"TRANSACTION":             5,
	"COMPLETED":               6,
	"ERROR":                   7,
	"GET_STATE":               8,
	"PUT_STATE":               9,
	"DEL_STATE":               10,
	"INVOKE_CHAINCODE":        11,
	"INVOKE_QUERY":            12,
	"RESPONSE":                13,
	"QUERY":                   14,
	"QUERY_COMPLETED":         15,
	"QUERY_ERROR":             16,
	"RANGE_QUERY_STATE":       17,
	"RANGE_QUERY_STATE_NEXT":  18,
	"RANGE_QUERY_STATE_CLOSE": 19,
	"KEEPALIVE":               20,
}

func (x ChaincodeMessage_Type) String() string {
	return proto.EnumName(ChaincodeMessage_Type_name, int32(x))
}
func (ChaincodeMessage_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{6, 0} }

// ChaincodeID contains the path as specified by the deploy transaction
// that created it as well as the hashCode that is generated by the
// system for the path. From the user level (ie, CLI, REST API and so on)
// deploy transaction is expected to provide the path and other requests
// are expected to provide the hashCode. The other value will be ignored.
// Internally, the structure could contain both values. For instance, the
// hashCode will be set when first generated using the path
type ChaincodeID struct {
	// deploy transaction will use the path
	Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	// all other requests will use the name (really a hashcode) generated by
	// the deploy transaction
	Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
}

func (m *ChaincodeID) Reset()                    { *m = ChaincodeID{} }
func (m *ChaincodeID) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeID) ProtoMessage()               {}
func (*ChaincodeID) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }

// Carries the chaincode function and its arguments.
// UnmarshalJSON in transaction.go converts the string-based REST/JSON input to
// the []byte-based current ChaincodeInput structure.
type ChaincodeInput struct {
	Args [][]byte `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
}

func (m *ChaincodeInput) Reset()                    { *m = ChaincodeInput{} }
func (m *ChaincodeInput) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeInput) ProtoMessage()               {}
func (*ChaincodeInput) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }

// Carries the chaincode specification. This is the actual metadata required for
// defining a chaincode.
type ChaincodeSpec struct {
	Type                 ChaincodeSpec_Type   `protobuf:"varint,1,opt,name=type,enum=protos.ChaincodeSpec_Type" json:"type,omitempty"`
	ChaincodeID          *ChaincodeID         `protobuf:"bytes,2,opt,name=chaincodeID" json:"chaincodeID,omitempty"`
	CtorMsg              *ChaincodeInput      `protobuf:"bytes,3,opt,name=ctorMsg" json:"ctorMsg,omitempty"`
	Timeout              int32                `protobuf:"varint,4,opt,name=timeout" json:"timeout,omitempty"`
	SecureContext        string               `protobuf:"bytes,5,opt,name=secureContext" json:"secureContext,omitempty"`
	ConfidentialityLevel ConfidentialityLevel `protobuf:"varint,6,opt,name=confidentialityLevel,enum=protos.ConfidentialityLevel" json:"confidentialityLevel,omitempty"`
	Metadata             []byte               `protobuf:"bytes,7,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Attributes           []string             `protobuf:"bytes,8,rep,name=attributes" json:"attributes,omitempty"`
}

func (m *ChaincodeSpec) Reset()                    { *m = ChaincodeSpec{} }
func (m *ChaincodeSpec) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeSpec) ProtoMessage()               {}
func (*ChaincodeSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }

func (m *ChaincodeSpec) GetChaincodeID() *ChaincodeID {
	if m != nil {
		return m.ChaincodeID
	}
	return nil
}

func (m *ChaincodeSpec) GetCtorMsg() *ChaincodeInput {
	if m != nil {
		return m.CtorMsg
	}
	return nil
}

// Specify the deployment of a chaincode.
// TODO: Define `codePackage`.
type ChaincodeDeploymentSpec struct {
	ChaincodeSpec *ChaincodeSpec `protobuf:"bytes,1,opt,name=chaincodeSpec" json:"chaincodeSpec,omitempty"`
	// Controls when the chaincode becomes executable.
	EffectiveDate *google_protobuf.Timestamp                   `protobuf:"bytes,2,opt,name=effectiveDate" json:"effectiveDate,omitempty"`
	CodePackage   []byte                                       `protobuf:"bytes,3,opt,name=codePackage,proto3" json:"codePackage,omitempty"`
	ExecEnv       ChaincodeDeploymentSpec_ExecutionEnvironment `protobuf:"varint,4,opt,name=execEnv,enum=protos.ChaincodeDeploymentSpec_ExecutionEnvironment" json:"execEnv,omitempty"`
}

func (m *ChaincodeDeploymentSpec) Reset()                    { *m = ChaincodeDeploymentSpec{} }
func (m *ChaincodeDeploymentSpec) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeDeploymentSpec) ProtoMessage()               {}
func (*ChaincodeDeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }

func (m *ChaincodeDeploymentSpec) GetChaincodeSpec() *ChaincodeSpec {
	if m != nil {
		return m.ChaincodeSpec
	}
	return nil
}

func (m *ChaincodeDeploymentSpec) GetEffectiveDate() *google_protobuf.Timestamp {
	if m != nil {
		return m.EffectiveDate
	}
	return nil
}

// Carries the chaincode function and its arguments.
type ChaincodeInvocationSpec struct {
	ChaincodeSpec *ChaincodeSpec `protobuf:"bytes,1,opt,name=chaincodeSpec" json:"chaincodeSpec,omitempty"`
	// This field can contain a user-specified ID generation algorithm
	// If supplied, this will be used to generate a ID
	// If not supplied (left empty), sha256base64 will be used
	// The algorithm consists of two parts:
	//  1, a hash function
	//  2, a decoding used to decode user (string) input to bytes
	// Currently, SHA256 with BASE64 is supported (e.g. idGenerationAlg='sha256base64')
	IdGenerationAlg string `protobuf:"bytes,2,opt,name=idGenerationAlg" json:"idGenerationAlg,omitempty"`
}

func (m *ChaincodeInvocationSpec) Reset()                    { *m = ChaincodeInvocationSpec{} }
func (m *ChaincodeInvocationSpec) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeInvocationSpec) ProtoMessage()               {}
func (*ChaincodeInvocationSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }

func (m *ChaincodeInvocationSpec) GetChaincodeSpec() *ChaincodeSpec {
	if m != nil {
		return m.ChaincodeSpec
	}
	return nil
}

// This structure contain transaction data that we send to the chaincode
// container shim and allow the chaincode to access through the shim interface.
// TODO: Consider remove this message and just pass the transaction object
// to the shim and/or allow the chaincode to query transactions.
type ChaincodeSecurityContext struct {
	CallerCert     []byte                     `protobuf:"bytes,1,opt,name=callerCert,proto3" json:"callerCert,omitempty"`
	CallerSign     []byte                     `protobuf:"bytes,2,opt,name=callerSign,proto3" json:"callerSign,omitempty"`
	Payload        []byte                     `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	Binding        []byte                     `protobuf:"bytes,4,opt,name=binding,proto3" json:"binding,omitempty"`
	Metadata       []byte                     `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"`
	ParentMetadata []byte                     `protobuf:"bytes,6,opt,name=parentMetadata,proto3" json:"parentMetadata,omitempty"`
	TxTimestamp    *google_protobuf.Timestamp `protobuf:"bytes,7,opt,name=txTimestamp" json:"txTimestamp,omitempty"`
}

func (m *ChaincodeSecurityContext) Reset()                    { *m = ChaincodeSecurityContext{} }
func (m *ChaincodeSecurityContext) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeSecurityContext) ProtoMessage()               {}
func (*ChaincodeSecurityContext) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }

func (m *ChaincodeSecurityContext) GetTxTimestamp() *google_protobuf.Timestamp {
	if m != nil {
		return m.TxTimestamp
	}
	return nil
}

type ChaincodeMessage struct {
	Type            ChaincodeMessage_Type      `protobuf:"varint,1,opt,name=type,enum=protos.ChaincodeMessage_Type" json:"type,omitempty"`
	Timestamp       *google_protobuf.Timestamp `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	Payload         []byte                     `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	Txid            string                     `protobuf:"bytes,4,opt,name=txid" json:"txid,omitempty"`
	SecurityContext *ChaincodeSecurityContext  `protobuf:"bytes,5,opt,name=securityContext" json:"securityContext,omitempty"`
	// event emmited by chaincode. Used only with Init or Invoke.
	// This event is then stored (currently)
	// with Block.NonHashData.TransactionResult
	ChaincodeEvent *ChaincodeEvent `protobuf:"bytes,6,opt,name=chaincodeEvent" json:"chaincodeEvent,omitempty"`
}

func (m *ChaincodeMessage) Reset()                    { *m = ChaincodeMessage{} }
func (m *ChaincodeMessage) String() string            { return proto.CompactTextString(m) }
func (*ChaincodeMessage) ProtoMessage()               {}
func (*ChaincodeMessage) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }

func (m *ChaincodeMessage) GetTimestamp() *google_protobuf.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *ChaincodeMessage) GetSecurityContext() *ChaincodeSecurityContext {
	if m != nil {
		return m.SecurityContext
	}
	return nil
}

func (m *ChaincodeMessage) GetChaincodeEvent() *ChaincodeEvent {
	if m != nil {
		return m.ChaincodeEvent
	}
	return nil
}

type PutStateInfo struct {
	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *PutStateInfo) Reset()                    { *m = PutStateInfo{} }
func (m *PutStateInfo) String() string            { return proto.CompactTextString(m) }
func (*PutStateInfo) ProtoMessage()               {}
func (*PutStateInfo) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }

type RangeQueryState struct {
	StartKey string `protobuf:"bytes,1,opt,name=startKey" json:"startKey,omitempty"`
	EndKey   string `protobuf:"bytes,2,opt,name=endKey" json:"endKey,omitempty"`
}

func (m *RangeQueryState) Reset()                    { *m = RangeQueryState{} }
func (m *RangeQueryState) String() string            { return proto.CompactTextString(m) }
func (*RangeQueryState) ProtoMessage()               {}
func (*RangeQueryState) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }

type RangeQueryStateNext struct {
	ID string `protobuf:"bytes,1,opt,name=ID,json=iD" json:"ID,omitempty"`
}

func (m *RangeQueryStateNext) Reset()                    { *m = RangeQueryStateNext{} }
func (m *RangeQueryStateNext) String() string            { return proto.CompactTextString(m) }
func (*RangeQueryStateNext) ProtoMessage()               {}
func (*RangeQueryStateNext) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }

type RangeQueryStateClose struct {
	ID string `protobuf:"bytes,1,opt,name=ID,json=iD" json:"ID,omitempty"`
}

func (m *RangeQueryStateClose) Reset()                    { *m = RangeQueryStateClose{} }
func (m *RangeQueryStateClose) String() string            { return proto.CompactTextString(m) }
func (*RangeQueryStateClose) ProtoMessage()               {}
func (*RangeQueryStateClose) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }

type RangeQueryStateKeyValue struct {
	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *RangeQueryStateKeyValue) Reset()                    { *m = RangeQueryStateKeyValue{} }
func (m *RangeQueryStateKeyValue) String() string            { return proto.CompactTextString(m) }
func (*RangeQueryStateKeyValue) ProtoMessage()               {}
func (*RangeQueryStateKeyValue) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }

type RangeQueryStateResponse struct {
	KeysAndValues []*RangeQueryStateKeyValue `protobuf:"bytes,1,rep,name=keysAndValues" json:"keysAndValues,omitempty"`
	HasMore       bool                       `protobuf:"varint,2,opt,name=hasMore" json:"hasMore,omitempty"`
	ID            string                     `protobuf:"bytes,3,opt,name=ID,json=iD" json:"ID,omitempty"`
}

func (m *RangeQueryStateResponse) Reset()                    { *m = RangeQueryStateResponse{} }
func (m *RangeQueryStateResponse) String() string            { return proto.CompactTextString(m) }
func (*RangeQueryStateResponse) ProtoMessage()               {}
func (*RangeQueryStateResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{12} }

func (m *RangeQueryStateResponse) GetKeysAndValues() []*RangeQueryStateKeyValue {
	if m != nil {
		return m.KeysAndValues
	}
	return nil
}

func init() {
	proto.RegisterType((*ChaincodeID)(nil), "protos.ChaincodeID")
	proto.RegisterType((*ChaincodeInput)(nil), "protos.ChaincodeInput")
	proto.RegisterType((*ChaincodeSpec)(nil), "protos.ChaincodeSpec")
	proto.RegisterType((*ChaincodeDeploymentSpec)(nil), "protos.ChaincodeDeploymentSpec")
	proto.RegisterType((*ChaincodeInvocationSpec)(nil), "protos.ChaincodeInvocationSpec")
	proto.RegisterType((*ChaincodeSecurityContext)(nil), "protos.ChaincodeSecurityContext")
	proto.RegisterType((*ChaincodeMessage)(nil), "protos.ChaincodeMessage")
	proto.RegisterType((*PutStateInfo)(nil), "protos.PutStateInfo")
	proto.RegisterType((*RangeQueryState)(nil), "protos.RangeQueryState")
	proto.RegisterType((*RangeQueryStateNext)(nil), "protos.RangeQueryStateNext")
	proto.RegisterType((*RangeQueryStateClose)(nil), "protos.RangeQueryStateClose")
	proto.RegisterType((*RangeQueryStateKeyValue)(nil), "protos.RangeQueryStateKeyValue")
	proto.RegisterType((*RangeQueryStateResponse)(nil), "protos.RangeQueryStateResponse")
	proto.RegisterEnum("protos.ConfidentialityLevel", ConfidentialityLevel_name, ConfidentialityLevel_value)
	proto.RegisterEnum("protos.ChaincodeSpec_Type", ChaincodeSpec_Type_name, ChaincodeSpec_Type_value)
	proto.RegisterEnum("protos.ChaincodeDeploymentSpec_ExecutionEnvironment", ChaincodeDeploymentSpec_ExecutionEnvironment_name, ChaincodeDeploymentSpec_ExecutionEnvironment_value)
	proto.RegisterEnum("protos.ChaincodeMessage_Type", ChaincodeMessage_Type_name, ChaincodeMessage_Type_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion3

// Client API for ChaincodeSupport service

type ChaincodeSupportClient interface {
	Register(ctx context.Context, opts ...grpc.CallOption) (ChaincodeSupport_RegisterClient, error)
}

type chaincodeSupportClient struct {
	cc *grpc.ClientConn
}

func NewChaincodeSupportClient(cc *grpc.ClientConn) ChaincodeSupportClient {
	return &chaincodeSupportClient{cc}
}

func (c *chaincodeSupportClient) Register(ctx context.Context, opts ...grpc.CallOption) (ChaincodeSupport_RegisterClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ChaincodeSupport_serviceDesc.Streams[0], c.cc, "/protos.ChaincodeSupport/Register", opts...)
	if err != nil {
		return nil, err
	}
	x := &chaincodeSupportRegisterClient{stream}
	return x, nil
}

type ChaincodeSupport_RegisterClient interface {
	Send(*ChaincodeMessage) error
	Recv() (*ChaincodeMessage, error)
	grpc.ClientStream
}

type chaincodeSupportRegisterClient struct {
	grpc.ClientStream
}

func (x *chaincodeSupportRegisterClient) Send(m *ChaincodeMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *chaincodeSupportRegisterClient) Recv() (*ChaincodeMessage, error) {
	m := new(ChaincodeMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for ChaincodeSupport service

type ChaincodeSupportServer interface {
	Register(ChaincodeSupport_RegisterServer) error
}

func RegisterChaincodeSupportServer(s *grpc.Server, srv ChaincodeSupportServer) {
	s.RegisterService(&_ChaincodeSupport_serviceDesc, srv)
}

func _ChaincodeSupport_Register_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ChaincodeSupportServer).Register(&chaincodeSupportRegisterServer{stream})
}

type ChaincodeSupport_RegisterServer interface {
	Send(*ChaincodeMessage) error
	Recv() (*ChaincodeMessage, error)
	grpc.ServerStream
}

type chaincodeSupportRegisterServer struct {
	grpc.ServerStream
}

func (x *chaincodeSupportRegisterServer) Send(m *ChaincodeMessage) error {
	return x.ServerStream.SendMsg(m)
}

func (x *chaincodeSupportRegisterServer) Recv() (*ChaincodeMessage, error) {
	m := new(ChaincodeMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _ChaincodeSupport_serviceDesc = grpc.ServiceDesc{
	ServiceName: "protos.ChaincodeSupport",
	HandlerType: (*ChaincodeSupportServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Register",
			Handler:       _ChaincodeSupport_Register_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: fileDescriptor2,
}

func init() { proto.RegisterFile("chaincode.proto", fileDescriptor2) }

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