server.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: grpc/proto/chain/server.proto

package chain

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
	math "math"
)

// 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
// 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.ProtoPackageIsVersion2 // please upgrade the proto package

func init() { proto.RegisterFile("grpc/proto/chain/server.proto", fileDescriptor_3248a815c2f630c6) }

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

// 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.SupportPackageIsVersion4

// LedgerCAClient is the client API for LedgerCA service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerCAClient interface {
	Info(ctx context.Context, in *ReqCaInfo, opts ...grpc.CallOption) (*ResultCAInfo, error)
	Enroll(ctx context.Context, in *ReqEnroll, opts ...grpc.CallOption) (*Result, error)
	Reenroll(ctx context.Context, in *ReqReenroll, opts ...grpc.CallOption) (*Result, error)
	Register(ctx context.Context, in *ReqRegister, opts ...grpc.CallOption) (*Result, error)
	AddAffiliation(ctx context.Context, in *ReqAddAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error)
	RemoveAffiliation(ctx context.Context, in *ReqRemoveAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error)
	ModifyAffiliation(ctx context.Context, in *ReqModifyAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error)
	GetAllAffiliations(ctx context.Context, in *ReqGetAllAffiliations, opts ...grpc.CallOption) (*ResultAffiliation, error)
	GetAllAffiliationsByCaName(ctx context.Context, in *ReqGetAllAffiliationsByCaName, opts ...grpc.CallOption) (*ResultAffiliation, error)
	GetAffiliation(ctx context.Context, in *ReqGetAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error)
	GetAffiliationByCaName(ctx context.Context, in *ReqGetAffiliationByCaName, opts ...grpc.CallOption) (*ResultAffiliation, error)
	GetAllIdentities(ctx context.Context, in *ReqGetAllIdentities, opts ...grpc.CallOption) (*ResultIdentityResponses, error)
	GetAllIdentitiesByCaName(ctx context.Context, in *ReqGetAllIdentitiesByCaName, opts ...grpc.CallOption) (*ResultIdentityResponses, error)
	CreateIdentity(ctx context.Context, in *ReqCreateIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error)
	ModifyIdentity(ctx context.Context, in *ReqModifyIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error)
	GetIdentity(ctx context.Context, in *ReqGetIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error)
	GetIdentityByCaName(ctx context.Context, in *ReqGetIdentityByCaName, opts ...grpc.CallOption) (*ResultIdentityResponse, error)
	RemoveIdentity(ctx context.Context, in *ReqRemoveIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error)
	CreateSigningIdentity(ctx context.Context, in *ReqCreateSigningIdentity, opts ...grpc.CallOption) (*ResultSigningIdentityResponse, error)
	GetSigningIdentity(ctx context.Context, in *ReqGetSigningIdentity, opts ...grpc.CallOption) (*ResultSigningIdentityResponse, error)
	Revoke(ctx context.Context, in *ReqRevoke, opts ...grpc.CallOption) (*ResultRevocationResponse, error)
}

type ledgerCAClient struct {
	cc *grpc.ClientConn
}

func NewLedgerCAClient(cc *grpc.ClientConn) LedgerCAClient {
	return &ledgerCAClient{cc}
}

func (c *ledgerCAClient) Info(ctx context.Context, in *ReqCaInfo, opts ...grpc.CallOption) (*ResultCAInfo, error) {
	out := new(ResultCAInfo)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/Info", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) Enroll(ctx context.Context, in *ReqEnroll, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/Enroll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) Reenroll(ctx context.Context, in *ReqReenroll, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/Reenroll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) Register(ctx context.Context, in *ReqRegister, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/Register", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) AddAffiliation(ctx context.Context, in *ReqAddAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/AddAffiliation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) RemoveAffiliation(ctx context.Context, in *ReqRemoveAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/RemoveAffiliation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) ModifyAffiliation(ctx context.Context, in *ReqModifyAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/ModifyAffiliation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAllAffiliations(ctx context.Context, in *ReqGetAllAffiliations, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAllAffiliations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAllAffiliationsByCaName(ctx context.Context, in *ReqGetAllAffiliationsByCaName, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAllAffiliationsByCaName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAffiliation(ctx context.Context, in *ReqGetAffiliation, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAffiliation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAffiliationByCaName(ctx context.Context, in *ReqGetAffiliationByCaName, opts ...grpc.CallOption) (*ResultAffiliation, error) {
	out := new(ResultAffiliation)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAffiliationByCaName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAllIdentities(ctx context.Context, in *ReqGetAllIdentities, opts ...grpc.CallOption) (*ResultIdentityResponses, error) {
	out := new(ResultIdentityResponses)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAllIdentities", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetAllIdentitiesByCaName(ctx context.Context, in *ReqGetAllIdentitiesByCaName, opts ...grpc.CallOption) (*ResultIdentityResponses, error) {
	out := new(ResultIdentityResponses)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetAllIdentitiesByCaName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) CreateIdentity(ctx context.Context, in *ReqCreateIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error) {
	out := new(ResultIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/CreateIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) ModifyIdentity(ctx context.Context, in *ReqModifyIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error) {
	out := new(ResultIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/ModifyIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetIdentity(ctx context.Context, in *ReqGetIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error) {
	out := new(ResultIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetIdentityByCaName(ctx context.Context, in *ReqGetIdentityByCaName, opts ...grpc.CallOption) (*ResultIdentityResponse, error) {
	out := new(ResultIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetIdentityByCaName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) RemoveIdentity(ctx context.Context, in *ReqRemoveIdentity, opts ...grpc.CallOption) (*ResultIdentityResponse, error) {
	out := new(ResultIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/RemoveIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) CreateSigningIdentity(ctx context.Context, in *ReqCreateSigningIdentity, opts ...grpc.CallOption) (*ResultSigningIdentityResponse, error) {
	out := new(ResultSigningIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/CreateSigningIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) GetSigningIdentity(ctx context.Context, in *ReqGetSigningIdentity, opts ...grpc.CallOption) (*ResultSigningIdentityResponse, error) {
	out := new(ResultSigningIdentityResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/GetSigningIdentity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerCAClient) Revoke(ctx context.Context, in *ReqRevoke, opts ...grpc.CallOption) (*ResultRevocationResponse, error) {
	out := new(ResultRevocationResponse)
	err := c.cc.Invoke(ctx, "/chain.LedgerCA/Revoke", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerCAServer is the server API for LedgerCA service.
type LedgerCAServer interface {
	Info(context.Context, *ReqCaInfo) (*ResultCAInfo, error)
	Enroll(context.Context, *ReqEnroll) (*Result, error)
	Reenroll(context.Context, *ReqReenroll) (*Result, error)
	Register(context.Context, *ReqRegister) (*Result, error)
	AddAffiliation(context.Context, *ReqAddAffiliation) (*ResultAffiliation, error)
	RemoveAffiliation(context.Context, *ReqRemoveAffiliation) (*ResultAffiliation, error)
	ModifyAffiliation(context.Context, *ReqModifyAffiliation) (*ResultAffiliation, error)
	GetAllAffiliations(context.Context, *ReqGetAllAffiliations) (*ResultAffiliation, error)
	GetAllAffiliationsByCaName(context.Context, *ReqGetAllAffiliationsByCaName) (*ResultAffiliation, error)
	GetAffiliation(context.Context, *ReqGetAffiliation) (*ResultAffiliation, error)
	GetAffiliationByCaName(context.Context, *ReqGetAffiliationByCaName) (*ResultAffiliation, error)
	GetAllIdentities(context.Context, *ReqGetAllIdentities) (*ResultIdentityResponses, error)
	GetAllIdentitiesByCaName(context.Context, *ReqGetAllIdentitiesByCaName) (*ResultIdentityResponses, error)
	CreateIdentity(context.Context, *ReqCreateIdentity) (*ResultIdentityResponse, error)
	ModifyIdentity(context.Context, *ReqModifyIdentity) (*ResultIdentityResponse, error)
	GetIdentity(context.Context, *ReqGetIdentity) (*ResultIdentityResponse, error)
	GetIdentityByCaName(context.Context, *ReqGetIdentityByCaName) (*ResultIdentityResponse, error)
	RemoveIdentity(context.Context, *ReqRemoveIdentity) (*ResultIdentityResponse, error)
	CreateSigningIdentity(context.Context, *ReqCreateSigningIdentity) (*ResultSigningIdentityResponse, error)
	GetSigningIdentity(context.Context, *ReqGetSigningIdentity) (*ResultSigningIdentityResponse, error)
	Revoke(context.Context, *ReqRevoke) (*ResultRevocationResponse, error)
}

func RegisterLedgerCAServer(s *grpc.Server, srv LedgerCAServer) {
	s.RegisterService(&_LedgerCA_serviceDesc, srv)
}

func _LedgerCA_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqCaInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).Info(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/Info",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).Info(ctx, req.(*ReqCaInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_Enroll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqEnroll)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).Enroll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/Enroll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).Enroll(ctx, req.(*ReqEnroll))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_Reenroll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqReenroll)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).Reenroll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/Reenroll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).Reenroll(ctx, req.(*ReqReenroll))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqRegister)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/Register",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).Register(ctx, req.(*ReqRegister))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_AddAffiliation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqAddAffiliation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).AddAffiliation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/AddAffiliation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).AddAffiliation(ctx, req.(*ReqAddAffiliation))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_RemoveAffiliation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqRemoveAffiliation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).RemoveAffiliation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/RemoveAffiliation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).RemoveAffiliation(ctx, req.(*ReqRemoveAffiliation))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_ModifyAffiliation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqModifyAffiliation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).ModifyAffiliation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/ModifyAffiliation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).ModifyAffiliation(ctx, req.(*ReqModifyAffiliation))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAllAffiliations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAllAffiliations)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAllAffiliations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAllAffiliations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAllAffiliations(ctx, req.(*ReqGetAllAffiliations))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAllAffiliationsByCaName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAllAffiliationsByCaName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAllAffiliationsByCaName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAllAffiliationsByCaName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAllAffiliationsByCaName(ctx, req.(*ReqGetAllAffiliationsByCaName))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAffiliation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAffiliation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAffiliation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAffiliation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAffiliation(ctx, req.(*ReqGetAffiliation))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAffiliationByCaName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAffiliationByCaName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAffiliationByCaName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAffiliationByCaName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAffiliationByCaName(ctx, req.(*ReqGetAffiliationByCaName))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAllIdentities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAllIdentities)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAllIdentities(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAllIdentities",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAllIdentities(ctx, req.(*ReqGetAllIdentities))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetAllIdentitiesByCaName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetAllIdentitiesByCaName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetAllIdentitiesByCaName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetAllIdentitiesByCaName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetAllIdentitiesByCaName(ctx, req.(*ReqGetAllIdentitiesByCaName))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_CreateIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqCreateIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).CreateIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/CreateIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).CreateIdentity(ctx, req.(*ReqCreateIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_ModifyIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqModifyIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).ModifyIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/ModifyIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).ModifyIdentity(ctx, req.(*ReqModifyIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetIdentity(ctx, req.(*ReqGetIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetIdentityByCaName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetIdentityByCaName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetIdentityByCaName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetIdentityByCaName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetIdentityByCaName(ctx, req.(*ReqGetIdentityByCaName))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_RemoveIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqRemoveIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).RemoveIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/RemoveIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).RemoveIdentity(ctx, req.(*ReqRemoveIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_CreateSigningIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqCreateSigningIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).CreateSigningIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/CreateSigningIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).CreateSigningIdentity(ctx, req.(*ReqCreateSigningIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_GetSigningIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqGetSigningIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).GetSigningIdentity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/GetSigningIdentity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).GetSigningIdentity(ctx, req.(*ReqGetSigningIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerCA_Revoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqRevoke)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerCAServer).Revoke(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerCA/Revoke",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerCAServer).Revoke(ctx, req.(*ReqRevoke))
	}
	return interceptor(ctx, in, info, handler)
}

var _LedgerCA_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.LedgerCA",
	HandlerType: (*LedgerCAServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Info",
			Handler:    _LedgerCA_Info_Handler,
		},
		{
			MethodName: "Enroll",
			Handler:    _LedgerCA_Enroll_Handler,
		},
		{
			MethodName: "Reenroll",
			Handler:    _LedgerCA_Reenroll_Handler,
		},
		{
			MethodName: "Register",
			Handler:    _LedgerCA_Register_Handler,
		},
		{
			MethodName: "AddAffiliation",
			Handler:    _LedgerCA_AddAffiliation_Handler,
		},
		{
			MethodName: "RemoveAffiliation",
			Handler:    _LedgerCA_RemoveAffiliation_Handler,
		},
		{
			MethodName: "ModifyAffiliation",
			Handler:    _LedgerCA_ModifyAffiliation_Handler,
		},
		{
			MethodName: "GetAllAffiliations",
			Handler:    _LedgerCA_GetAllAffiliations_Handler,
		},
		{
			MethodName: "GetAllAffiliationsByCaName",
			Handler:    _LedgerCA_GetAllAffiliationsByCaName_Handler,
		},
		{
			MethodName: "GetAffiliation",
			Handler:    _LedgerCA_GetAffiliation_Handler,
		},
		{
			MethodName: "GetAffiliationByCaName",
			Handler:    _LedgerCA_GetAffiliationByCaName_Handler,
		},
		{
			MethodName: "GetAllIdentities",
			Handler:    _LedgerCA_GetAllIdentities_Handler,
		},
		{
			MethodName: "GetAllIdentitiesByCaName",
			Handler:    _LedgerCA_GetAllIdentitiesByCaName_Handler,
		},
		{
			MethodName: "CreateIdentity",
			Handler:    _LedgerCA_CreateIdentity_Handler,
		},
		{
			MethodName: "ModifyIdentity",
			Handler:    _LedgerCA_ModifyIdentity_Handler,
		},
		{
			MethodName: "GetIdentity",
			Handler:    _LedgerCA_GetIdentity_Handler,
		},
		{
			MethodName: "GetIdentityByCaName",
			Handler:    _LedgerCA_GetIdentityByCaName_Handler,
		},
		{
			MethodName: "RemoveIdentity",
			Handler:    _LedgerCA_RemoveIdentity_Handler,
		},
		{
			MethodName: "CreateSigningIdentity",
			Handler:    _LedgerCA_CreateSigningIdentity_Handler,
		},
		{
			MethodName: "GetSigningIdentity",
			Handler:    _LedgerCA_GetSigningIdentity_Handler,
		},
		{
			MethodName: "Revoke",
			Handler:    _LedgerCA_Revoke_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/proto/chain/server.proto",
}

// LedgerChannelClient is the client API for LedgerChannel service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerChannelClient interface {
	Create(ctx context.Context, in *ChannelCreate, opts ...grpc.CallOption) (*Result, error)
	Join(ctx context.Context, in *ChannelJoin, opts ...grpc.CallOption) (*Result, error)
	List(ctx context.Context, in *ChannelList, opts ...grpc.CallOption) (*ResultArr, error)
}

type ledgerChannelClient struct {
	cc *grpc.ClientConn
}

func NewLedgerChannelClient(cc *grpc.ClientConn) LedgerChannelClient {
	return &ledgerChannelClient{cc}
}

func (c *ledgerChannelClient) Create(ctx context.Context, in *ChannelCreate, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChannel/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChannelClient) Join(ctx context.Context, in *ChannelJoin, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChannel/Join", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChannelClient) List(ctx context.Context, in *ChannelList, opts ...grpc.CallOption) (*ResultArr, error) {
	out := new(ResultArr)
	err := c.cc.Invoke(ctx, "/chain.LedgerChannel/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerChannelServer is the server API for LedgerChannel service.
type LedgerChannelServer interface {
	Create(context.Context, *ChannelCreate) (*Result, error)
	Join(context.Context, *ChannelJoin) (*Result, error)
	List(context.Context, *ChannelList) (*ResultArr, error)
}

func RegisterLedgerChannelServer(s *grpc.Server, srv LedgerChannelServer) {
	s.RegisterService(&_LedgerChannel_serviceDesc, srv)
}

func _LedgerChannel_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChannelServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChannel/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChannelServer).Create(ctx, req.(*ChannelCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChannel_Join_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelJoin)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChannelServer).Join(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChannel/Join",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChannelServer).Join(ctx, req.(*ChannelJoin))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChannel_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChannelServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChannel/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChannelServer).List(ctx, req.(*ChannelList))
	}
	return interceptor(ctx, in, info, handler)
}

var _LedgerChannel_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.LedgerChannel",
	HandlerType: (*LedgerChannelServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _LedgerChannel_Create_Handler,
		},
		{
			MethodName: "Join",
			Handler:    _LedgerChannel_Join_Handler,
		},
		{
			MethodName: "List",
			Handler:    _LedgerChannel_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/proto/chain/server.proto",
}

// LedgerChainCodeClient is the client API for LedgerChainCode service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerChainCodeClient interface {
	UploadCC(ctx context.Context, opts ...grpc.CallOption) (LedgerChainCode_UploadCCClient, error)
	InstallCC(ctx context.Context, in *Install, opts ...grpc.CallOption) (*Result, error)
	InstalledCC(ctx context.Context, in *Installed, opts ...grpc.CallOption) (*ResultCCList, error)
	InstantiateCC(ctx context.Context, in *Instantiate, opts ...grpc.CallOption) (*Result, error)
	InstantiatedCC(ctx context.Context, in *Instantiated, opts ...grpc.CallOption) (*ResultCCList, error)
	UpgradeCC(ctx context.Context, in *Upgrade, opts ...grpc.CallOption) (*Result, error)
	InvokeCC(ctx context.Context, in *Invoke, opts ...grpc.CallOption) (*Result, error)
	InvokeCCAsync(ctx context.Context, in *InvokeAsync, opts ...grpc.CallOption) (*Result, error)
	QueryCC(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Result, error)
}

type ledgerChainCodeClient struct {
	cc *grpc.ClientConn
}

func NewLedgerChainCodeClient(cc *grpc.ClientConn) LedgerChainCodeClient {
	return &ledgerChainCodeClient{cc}
}

func (c *ledgerChainCodeClient) UploadCC(ctx context.Context, opts ...grpc.CallOption) (LedgerChainCode_UploadCCClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LedgerChainCode_serviceDesc.Streams[0], "/chain.LedgerChainCode/UploadCC", opts...)
	if err != nil {
		return nil, err
	}
	x := &ledgerChainCodeUploadCCClient{stream}
	return x, nil
}

type LedgerChainCode_UploadCCClient interface {
	Send(*Upload) error
	CloseAndRecv() (*ResultUpload, error)
	grpc.ClientStream
}

type ledgerChainCodeUploadCCClient struct {
	grpc.ClientStream
}

func (x *ledgerChainCodeUploadCCClient) Send(m *Upload) error {
	return x.ClientStream.SendMsg(m)
}

func (x *ledgerChainCodeUploadCCClient) CloseAndRecv() (*ResultUpload, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(ResultUpload)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ledgerChainCodeClient) InstallCC(ctx context.Context, in *Install, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InstallCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) InstalledCC(ctx context.Context, in *Installed, opts ...grpc.CallOption) (*ResultCCList, error) {
	out := new(ResultCCList)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InstalledCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) InstantiateCC(ctx context.Context, in *Instantiate, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InstantiateCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) InstantiatedCC(ctx context.Context, in *Instantiated, opts ...grpc.CallOption) (*ResultCCList, error) {
	out := new(ResultCCList)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InstantiatedCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) UpgradeCC(ctx context.Context, in *Upgrade, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/UpgradeCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) InvokeCC(ctx context.Context, in *Invoke, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InvokeCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) InvokeCCAsync(ctx context.Context, in *InvokeAsync, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/InvokeCCAsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerChainCodeClient) QueryCC(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerChainCode/QueryCC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerChainCodeServer is the server API for LedgerChainCode service.
type LedgerChainCodeServer interface {
	UploadCC(LedgerChainCode_UploadCCServer) error
	InstallCC(context.Context, *Install) (*Result, error)
	InstalledCC(context.Context, *Installed) (*ResultCCList, error)
	InstantiateCC(context.Context, *Instantiate) (*Result, error)
	InstantiatedCC(context.Context, *Instantiated) (*ResultCCList, error)
	UpgradeCC(context.Context, *Upgrade) (*Result, error)
	InvokeCC(context.Context, *Invoke) (*Result, error)
	InvokeCCAsync(context.Context, *InvokeAsync) (*Result, error)
	QueryCC(context.Context, *Query) (*Result, error)
}

func RegisterLedgerChainCodeServer(s *grpc.Server, srv LedgerChainCodeServer) {
	s.RegisterService(&_LedgerChainCode_serviceDesc, srv)
}

func _LedgerChainCode_UploadCC_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LedgerChainCodeServer).UploadCC(&ledgerChainCodeUploadCCServer{stream})
}

type LedgerChainCode_UploadCCServer interface {
	SendAndClose(*ResultUpload) error
	Recv() (*Upload, error)
	grpc.ServerStream
}

type ledgerChainCodeUploadCCServer struct {
	grpc.ServerStream
}

func (x *ledgerChainCodeUploadCCServer) SendAndClose(m *ResultUpload) error {
	return x.ServerStream.SendMsg(m)
}

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

func _LedgerChainCode_InstallCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Install)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InstallCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InstallCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InstallCC(ctx, req.(*Install))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_InstalledCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Installed)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InstalledCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InstalledCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InstalledCC(ctx, req.(*Installed))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_InstantiateCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Instantiate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InstantiateCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InstantiateCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InstantiateCC(ctx, req.(*Instantiate))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_InstantiatedCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Instantiated)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InstantiatedCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InstantiatedCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InstantiatedCC(ctx, req.(*Instantiated))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_UpgradeCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Upgrade)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).UpgradeCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/UpgradeCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).UpgradeCC(ctx, req.(*Upgrade))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_InvokeCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Invoke)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InvokeCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InvokeCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InvokeCC(ctx, req.(*Invoke))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_InvokeCCAsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvokeAsync)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).InvokeCCAsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/InvokeCCAsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).InvokeCCAsync(ctx, req.(*InvokeAsync))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerChainCode_QueryCC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerChainCodeServer).QueryCC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerChainCode/QueryCC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerChainCodeServer).QueryCC(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

var _LedgerChainCode_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.LedgerChainCode",
	HandlerType: (*LedgerChainCodeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InstallCC",
			Handler:    _LedgerChainCode_InstallCC_Handler,
		},
		{
			MethodName: "InstalledCC",
			Handler:    _LedgerChainCode_InstalledCC_Handler,
		},
		{
			MethodName: "InstantiateCC",
			Handler:    _LedgerChainCode_InstantiateCC_Handler,
		},
		{
			MethodName: "InstantiatedCC",
			Handler:    _LedgerChainCode_InstantiatedCC_Handler,
		},
		{
			MethodName: "UpgradeCC",
			Handler:    _LedgerChainCode_UpgradeCC_Handler,
		},
		{
			MethodName: "InvokeCC",
			Handler:    _LedgerChainCode_InvokeCC_Handler,
		},
		{
			MethodName: "InvokeCCAsync",
			Handler:    _LedgerChainCode_InvokeCCAsync_Handler,
		},
		{
			MethodName: "QueryCC",
			Handler:    _LedgerChainCode_QueryCC_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UploadCC",
			Handler:       _LedgerChainCode_UploadCC_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "grpc/proto/chain/server.proto",
}

// LedgerPeerClient is the client API for LedgerPeer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerPeerClient interface {
	LocalPeers(ctx context.Context, in *ReqLocalPeers, opts ...grpc.CallOption) (*ResultPeers, error)
	ChannelPeers(ctx context.Context, in *ReqChannelPeers, opts ...grpc.CallOption) (*ResultPeers, error)
}

type ledgerPeerClient struct {
	cc *grpc.ClientConn
}

func NewLedgerPeerClient(cc *grpc.ClientConn) LedgerPeerClient {
	return &ledgerPeerClient{cc}
}

func (c *ledgerPeerClient) LocalPeers(ctx context.Context, in *ReqLocalPeers, opts ...grpc.CallOption) (*ResultPeers, error) {
	out := new(ResultPeers)
	err := c.cc.Invoke(ctx, "/chain.LedgerPeer/LocalPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerPeerClient) ChannelPeers(ctx context.Context, in *ReqChannelPeers, opts ...grpc.CallOption) (*ResultPeers, error) {
	out := new(ResultPeers)
	err := c.cc.Invoke(ctx, "/chain.LedgerPeer/ChannelPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerPeerServer is the server API for LedgerPeer service.
type LedgerPeerServer interface {
	LocalPeers(context.Context, *ReqLocalPeers) (*ResultPeers, error)
	ChannelPeers(context.Context, *ReqChannelPeers) (*ResultPeers, error)
}

func RegisterLedgerPeerServer(s *grpc.Server, srv LedgerPeerServer) {
	s.RegisterService(&_LedgerPeer_serviceDesc, srv)
}

func _LedgerPeer_LocalPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqLocalPeers)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerPeerServer).LocalPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerPeer/LocalPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerPeerServer).LocalPeers(ctx, req.(*ReqLocalPeers))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerPeer_ChannelPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqChannelPeers)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerPeerServer).ChannelPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerPeer/ChannelPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerPeerServer).ChannelPeers(ctx, req.(*ReqChannelPeers))
	}
	return interceptor(ctx, in, info, handler)
}

var _LedgerPeer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.LedgerPeer",
	HandlerType: (*LedgerPeerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "LocalPeers",
			Handler:    _LedgerPeer_LocalPeers_Handler,
		},
		{
			MethodName: "ChannelPeers",
			Handler:    _LedgerPeer_ChannelPeers_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/proto/chain/server.proto",
}

// LedgerClient is the client API for Ledger service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerClient interface {
	QueryLedgerInfo(ctx context.Context, in *ReqInfo, opts ...grpc.CallOption) (*ResultChannelInfo, error)
	QueryLedgerBlockByHeight(ctx context.Context, in *ReqBlockByHeight, opts ...grpc.CallOption) (*ResultBlock, error)
	QueryLedgerBlockByHash(ctx context.Context, in *ReqBlockByHash, opts ...grpc.CallOption) (*ResultBlock, error)
	QueryLedgerBlockByTxID(ctx context.Context, in *ReqBlockByTxID, opts ...grpc.CallOption) (*ResultBlock, error)
	QueryLedgerInfoSpec(ctx context.Context, in *ReqInfoSpec, opts ...grpc.CallOption) (*ResultChannelInfo, error)
	QueryLedgerBlockByHeightSpec(ctx context.Context, in *ReqBlockByHeightSpec, opts ...grpc.CallOption) (*ResultBlock, error)
	QueryLedgerBlockByHashSpec(ctx context.Context, in *ReqBlockByHashSpec, opts ...grpc.CallOption) (*ResultBlock, error)
	QueryLedgerBlockByTxIDSpec(ctx context.Context, in *ReqBlockByTxIDSpec, opts ...grpc.CallOption) (*ResultBlock, error)
}

type ledgerClient struct {
	cc *grpc.ClientConn
}

func NewLedgerClient(cc *grpc.ClientConn) LedgerClient {
	return &ledgerClient{cc}
}

func (c *ledgerClient) QueryLedgerInfo(ctx context.Context, in *ReqInfo, opts ...grpc.CallOption) (*ResultChannelInfo, error) {
	out := new(ResultChannelInfo)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByHeight(ctx context.Context, in *ReqBlockByHeight, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByHeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByHash(ctx context.Context, in *ReqBlockByHash, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByTxID(ctx context.Context, in *ReqBlockByTxID, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByTxID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerInfoSpec(ctx context.Context, in *ReqInfoSpec, opts ...grpc.CallOption) (*ResultChannelInfo, error) {
	out := new(ResultChannelInfo)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerInfoSpec", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByHeightSpec(ctx context.Context, in *ReqBlockByHeightSpec, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByHeightSpec", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByHashSpec(ctx context.Context, in *ReqBlockByHashSpec, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByHashSpec", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerClient) QueryLedgerBlockByTxIDSpec(ctx context.Context, in *ReqBlockByTxIDSpec, opts ...grpc.CallOption) (*ResultBlock, error) {
	out := new(ResultBlock)
	err := c.cc.Invoke(ctx, "/chain.Ledger/QueryLedgerBlockByTxIDSpec", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerServer is the server API for Ledger service.
type LedgerServer interface {
	QueryLedgerInfo(context.Context, *ReqInfo) (*ResultChannelInfo, error)
	QueryLedgerBlockByHeight(context.Context, *ReqBlockByHeight) (*ResultBlock, error)
	QueryLedgerBlockByHash(context.Context, *ReqBlockByHash) (*ResultBlock, error)
	QueryLedgerBlockByTxID(context.Context, *ReqBlockByTxID) (*ResultBlock, error)
	QueryLedgerInfoSpec(context.Context, *ReqInfoSpec) (*ResultChannelInfo, error)
	QueryLedgerBlockByHeightSpec(context.Context, *ReqBlockByHeightSpec) (*ResultBlock, error)
	QueryLedgerBlockByHashSpec(context.Context, *ReqBlockByHashSpec) (*ResultBlock, error)
	QueryLedgerBlockByTxIDSpec(context.Context, *ReqBlockByTxIDSpec) (*ResultBlock, error)
}

func RegisterLedgerServer(s *grpc.Server, srv LedgerServer) {
	s.RegisterService(&_Ledger_serviceDesc, srv)
}

func _Ledger_QueryLedgerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerInfo(ctx, req.(*ReqInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByHeight)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByHeight(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByHeight",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByHeight(ctx, req.(*ReqBlockByHeight))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByHash)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByHash(ctx, req.(*ReqBlockByHash))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByTxID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByTxID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByTxID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByTxID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByTxID(ctx, req.(*ReqBlockByTxID))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerInfoSpec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqInfoSpec)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerInfoSpec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerInfoSpec",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerInfoSpec(ctx, req.(*ReqInfoSpec))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByHeightSpec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByHeightSpec)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByHeightSpec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByHeightSpec",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByHeightSpec(ctx, req.(*ReqBlockByHeightSpec))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByHashSpec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByHashSpec)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByHashSpec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByHashSpec",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByHashSpec(ctx, req.(*ReqBlockByHashSpec))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ledger_QueryLedgerBlockByTxIDSpec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqBlockByTxIDSpec)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerServer).QueryLedgerBlockByTxIDSpec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.Ledger/QueryLedgerBlockByTxIDSpec",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerServer).QueryLedgerBlockByTxIDSpec(ctx, req.(*ReqBlockByTxIDSpec))
	}
	return interceptor(ctx, in, info, handler)
}

var _Ledger_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.Ledger",
	HandlerType: (*LedgerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "QueryLedgerInfo",
			Handler:    _Ledger_QueryLedgerInfo_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByHeight",
			Handler:    _Ledger_QueryLedgerBlockByHeight_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByHash",
			Handler:    _Ledger_QueryLedgerBlockByHash_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByTxID",
			Handler:    _Ledger_QueryLedgerBlockByTxID_Handler,
		},
		{
			MethodName: "QueryLedgerInfoSpec",
			Handler:    _Ledger_QueryLedgerInfoSpec_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByHeightSpec",
			Handler:    _Ledger_QueryLedgerBlockByHeightSpec_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByHashSpec",
			Handler:    _Ledger_QueryLedgerBlockByHashSpec_Handler,
		},
		{
			MethodName: "QueryLedgerBlockByTxIDSpec",
			Handler:    _Ledger_QueryLedgerBlockByTxIDSpec_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/proto/chain/server.proto",
}

// LedgerConfigClient is the client API for LedgerConfig service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LedgerConfigClient interface {
	ListConfig(ctx context.Context, in *ReqConfigList, opts ...grpc.CallOption) (*ResultConfigList, error)
	GetConfig(ctx context.Context, in *ReqConfig, opts ...grpc.CallOption) (*ResultConfig, error)
	RecoverConfig(ctx context.Context, in *ReqConfigRecover, opts ...grpc.CallOption) (*Result, error)
	InitConfig(ctx context.Context, in *ReqInit, opts ...grpc.CallOption) (*Result, error)
}

type ledgerConfigClient struct {
	cc *grpc.ClientConn
}

func NewLedgerConfigClient(cc *grpc.ClientConn) LedgerConfigClient {
	return &ledgerConfigClient{cc}
}

func (c *ledgerConfigClient) ListConfig(ctx context.Context, in *ReqConfigList, opts ...grpc.CallOption) (*ResultConfigList, error) {
	out := new(ResultConfigList)
	err := c.cc.Invoke(ctx, "/chain.LedgerConfig/ListConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerConfigClient) GetConfig(ctx context.Context, in *ReqConfig, opts ...grpc.CallOption) (*ResultConfig, error) {
	out := new(ResultConfig)
	err := c.cc.Invoke(ctx, "/chain.LedgerConfig/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerConfigClient) RecoverConfig(ctx context.Context, in *ReqConfigRecover, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerConfig/RecoverConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ledgerConfigClient) InitConfig(ctx context.Context, in *ReqInit, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/chain.LedgerConfig/InitConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LedgerConfigServer is the server API for LedgerConfig service.
type LedgerConfigServer interface {
	ListConfig(context.Context, *ReqConfigList) (*ResultConfigList, error)
	GetConfig(context.Context, *ReqConfig) (*ResultConfig, error)
	RecoverConfig(context.Context, *ReqConfigRecover) (*Result, error)
	InitConfig(context.Context, *ReqInit) (*Result, error)
}

func RegisterLedgerConfigServer(s *grpc.Server, srv LedgerConfigServer) {
	s.RegisterService(&_LedgerConfig_serviceDesc, srv)
}

func _LedgerConfig_ListConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqConfigList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerConfigServer).ListConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerConfig/ListConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerConfigServer).ListConfig(ctx, req.(*ReqConfigList))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerConfig_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqConfig)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerConfigServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerConfig/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerConfigServer).GetConfig(ctx, req.(*ReqConfig))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerConfig_RecoverConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqConfigRecover)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerConfigServer).RecoverConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerConfig/RecoverConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerConfigServer).RecoverConfig(ctx, req.(*ReqConfigRecover))
	}
	return interceptor(ctx, in, info, handler)
}

func _LedgerConfig_InitConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqInit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LedgerConfigServer).InitConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chain.LedgerConfig/InitConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LedgerConfigServer).InitConfig(ctx, req.(*ReqInit))
	}
	return interceptor(ctx, in, info, handler)
}

var _LedgerConfig_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chain.LedgerConfig",
	HandlerType: (*LedgerConfigServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListConfig",
			Handler:    _LedgerConfig_ListConfig_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _LedgerConfig_GetConfig_Handler,
		},
		{
			MethodName: "RecoverConfig",
			Handler:    _LedgerConfig_RecoverConfig_Handler,
		},
		{
			MethodName: "InitConfig",
			Handler:    _LedgerConfig_InitConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/proto/chain/server.proto",
}