github.com/aergoio/aergo@v1.3.1/types/rpc.pb.go

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

package types

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

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

type CommitStatus int32

const (
	CommitStatus_TX_OK                   CommitStatus = 0
	CommitStatus_TX_NONCE_TOO_LOW        CommitStatus = 1
	CommitStatus_TX_ALREADY_EXISTS       CommitStatus = 2
	CommitStatus_TX_INVALID_HASH         CommitStatus = 3
	CommitStatus_TX_INVALID_SIGN         CommitStatus = 4
	CommitStatus_TX_INVALID_FORMAT       CommitStatus = 5
	CommitStatus_TX_INSUFFICIENT_BALANCE CommitStatus = 6
	CommitStatus_TX_HAS_SAME_NONCE       CommitStatus = 7
	CommitStatus_TX_INTERNAL_ERROR       CommitStatus = 9
)

var CommitStatus_name = map[int32]string{
	0: "TX_OK",
	1: "TX_NONCE_TOO_LOW",
	2: "TX_ALREADY_EXISTS",
	3: "TX_INVALID_HASH",
	4: "TX_INVALID_SIGN",
	5: "TX_INVALID_FORMAT",
	6: "TX_INSUFFICIENT_BALANCE",
	7: "TX_HAS_SAME_NONCE",
	9: "TX_INTERNAL_ERROR",
}
var CommitStatus_value = map[string]int32{
	"TX_OK":                   0,
	"TX_NONCE_TOO_LOW":        1,
	"TX_ALREADY_EXISTS":       2,
	"TX_INVALID_HASH":         3,
	"TX_INVALID_SIGN":         4,
	"TX_INVALID_FORMAT":       5,
	"TX_INSUFFICIENT_BALANCE": 6,
	"TX_HAS_SAME_NONCE":       7,
	"TX_INTERNAL_ERROR":       9,
}

func (x CommitStatus) String() string {
	return proto.EnumName(CommitStatus_name, int32(x))
}
func (CommitStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{0}
}

type VerifyStatus int32

const (
	VerifyStatus_VERIFY_STATUS_OK             VerifyStatus = 0
	VerifyStatus_VERIFY_STATUS_SIGN_NOT_MATCH VerifyStatus = 1
	VerifyStatus_VERIFY_STATUS_INVALID_HASH   VerifyStatus = 2
)

var VerifyStatus_name = map[int32]string{
	0: "VERIFY_STATUS_OK",
	1: "VERIFY_STATUS_SIGN_NOT_MATCH",
	2: "VERIFY_STATUS_INVALID_HASH",
}
var VerifyStatus_value = map[string]int32{
	"VERIFY_STATUS_OK":             0,
	"VERIFY_STATUS_SIGN_NOT_MATCH": 1,
	"VERIFY_STATUS_INVALID_HASH":   2,
}

func (x VerifyStatus) String() string {
	return proto.EnumName(VerifyStatus_name, int32(x))
}
func (VerifyStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{1}
}

// BlockchainStatus is current status of blockchain
type BlockchainStatus struct {
	BestBlockHash        []byte     `protobuf:"bytes,1,opt,name=best_block_hash,json=bestBlockHash,proto3" json:"best_block_hash,omitempty"`
	BestHeight           uint64     `protobuf:"varint,2,opt,name=best_height,json=bestHeight,proto3" json:"best_height,omitempty"`
	ConsensusInfo        string     `protobuf:"bytes,3,opt,name=consensus_info,json=consensusInfo,proto3" json:"consensus_info,omitempty"`
	BestChainIdHash      []byte     `protobuf:"bytes,4,opt,name=best_chain_id_hash,json=bestChainIdHash,proto3" json:"best_chain_id_hash,omitempty"`
	ChainInfo            *ChainInfo `protobuf:"bytes,5,opt,name=chain_info,json=chainInfo,proto3" json:"chain_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *BlockchainStatus) Reset()         { *m = BlockchainStatus{} }
func (m *BlockchainStatus) String() string { return proto.CompactTextString(m) }
func (*BlockchainStatus) ProtoMessage()    {}
func (*BlockchainStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{0}
}
func (m *BlockchainStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockchainStatus.Unmarshal(m, b)
}
func (m *BlockchainStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockchainStatus.Marshal(b, m, deterministic)
}
func (dst *BlockchainStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockchainStatus.Merge(dst, src)
}
func (m *BlockchainStatus) XXX_Size() int {
	return xxx_messageInfo_BlockchainStatus.Size(m)
}
func (m *BlockchainStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockchainStatus.DiscardUnknown(m)
}

var xxx_messageInfo_BlockchainStatus proto.InternalMessageInfo

func (m *BlockchainStatus) GetBestBlockHash() []byte {
	if m != nil {
		return m.BestBlockHash
	}
	return nil
}

func (m *BlockchainStatus) GetBestHeight() uint64 {
	if m != nil {
		return m.BestHeight
	}
	return 0
}

func (m *BlockchainStatus) GetConsensusInfo() string {
	if m != nil {
		return m.ConsensusInfo
	}
	return ""
}

func (m *BlockchainStatus) GetBestChainIdHash() []byte {
	if m != nil {
		return m.BestChainIdHash
	}
	return nil
}

func (m *BlockchainStatus) GetChainInfo() *ChainInfo {
	if m != nil {
		return m.ChainInfo
	}
	return nil
}

type ChainId struct {
	Magic                string   `protobuf:"bytes,1,opt,name=magic,proto3" json:"magic,omitempty"`
	Public               bool     `protobuf:"varint,2,opt,name=public,proto3" json:"public,omitempty"`
	Mainnet              bool     `protobuf:"varint,3,opt,name=mainnet,proto3" json:"mainnet,omitempty"`
	Consensus            string   `protobuf:"bytes,4,opt,name=consensus,proto3" json:"consensus,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChainId) Reset()         { *m = ChainId{} }
func (m *ChainId) String() string { return proto.CompactTextString(m) }
func (*ChainId) ProtoMessage()    {}
func (*ChainId) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{1}
}
func (m *ChainId) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChainId.Unmarshal(m, b)
}
func (m *ChainId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChainId.Marshal(b, m, deterministic)
}
func (dst *ChainId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChainId.Merge(dst, src)
}
func (m *ChainId) XXX_Size() int {
	return xxx_messageInfo_ChainId.Size(m)
}
func (m *ChainId) XXX_DiscardUnknown() {
	xxx_messageInfo_ChainId.DiscardUnknown(m)
}

var xxx_messageInfo_ChainId proto.InternalMessageInfo

func (m *ChainId) GetMagic() string {
	if m != nil {
		return m.Magic
	}
	return ""
}

func (m *ChainId) GetPublic() bool {
	if m != nil {
		return m.Public
	}
	return false
}

func (m *ChainId) GetMainnet() bool {
	if m != nil {
		return m.Mainnet
	}
	return false
}

func (m *ChainId) GetConsensus() string {
	if m != nil {
		return m.Consensus
	}
	return ""
}

// ChainInfo returns chain configuration
type ChainInfo struct {
	Id                   *ChainId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	BpNumber             uint32   `protobuf:"varint,2,opt,name=bpNumber,proto3" json:"bpNumber,omitempty"`
	Maxblocksize         uint64   `protobuf:"varint,3,opt,name=maxblocksize,proto3" json:"maxblocksize,omitempty"`
	Maxtokens            []byte   `protobuf:"bytes,4,opt,name=maxtokens,proto3" json:"maxtokens,omitempty"`
	Stakingminimum       []byte   `protobuf:"bytes,5,opt,name=stakingminimum,proto3" json:"stakingminimum,omitempty"`
	Totalstaking         []byte   `protobuf:"bytes,6,opt,name=totalstaking,proto3" json:"totalstaking,omitempty"`
	Gasprice             []byte   `protobuf:"bytes,7,opt,name=gasprice,proto3" json:"gasprice,omitempty"`
	Nameprice            []byte   `protobuf:"bytes,8,opt,name=nameprice,proto3" json:"nameprice,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChainInfo) Reset()         { *m = ChainInfo{} }
func (m *ChainInfo) String() string { return proto.CompactTextString(m) }
func (*ChainInfo) ProtoMessage()    {}
func (*ChainInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{2}
}
func (m *ChainInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChainInfo.Unmarshal(m, b)
}
func (m *ChainInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChainInfo.Marshal(b, m, deterministic)
}
func (dst *ChainInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChainInfo.Merge(dst, src)
}
func (m *ChainInfo) XXX_Size() int {
	return xxx_messageInfo_ChainInfo.Size(m)
}
func (m *ChainInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ChainInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ChainInfo proto.InternalMessageInfo

func (m *ChainInfo) GetId() *ChainId {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ChainInfo) GetBpNumber() uint32 {
	if m != nil {
		return m.BpNumber
	}
	return 0
}

func (m *ChainInfo) GetMaxblocksize() uint64 {
	if m != nil {
		return m.Maxblocksize
	}
	return 0
}

func (m *ChainInfo) GetMaxtokens() []byte {
	if m != nil {
		return m.Maxtokens
	}
	return nil
}

func (m *ChainInfo) GetStakingminimum() []byte {
	if m != nil {
		return m.Stakingminimum
	}
	return nil
}

func (m *ChainInfo) GetTotalstaking() []byte {
	if m != nil {
		return m.Totalstaking
	}
	return nil
}

func (m *ChainInfo) GetGasprice() []byte {
	if m != nil {
		return m.Gasprice
	}
	return nil
}

func (m *ChainInfo) GetNameprice() []byte {
	if m != nil {
		return m.Nameprice
	}
	return nil
}

// ChainStats corresponds to a chain statistics report.
type ChainStats struct {
	Report               string   `protobuf:"bytes,1,opt,name=report,proto3" json:"report,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChainStats) Reset()         { *m = ChainStats{} }
func (m *ChainStats) String() string { return proto.CompactTextString(m) }
func (*ChainStats) ProtoMessage()    {}
func (*ChainStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{3}
}
func (m *ChainStats) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChainStats.Unmarshal(m, b)
}
func (m *ChainStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChainStats.Marshal(b, m, deterministic)
}
func (dst *ChainStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChainStats.Merge(dst, src)
}
func (m *ChainStats) XXX_Size() int {
	return xxx_messageInfo_ChainStats.Size(m)
}
func (m *ChainStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ChainStats.DiscardUnknown(m)
}

var xxx_messageInfo_ChainStats proto.InternalMessageInfo

func (m *ChainStats) GetReport() string {
	if m != nil {
		return m.Report
	}
	return ""
}

type Input struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Address              [][]byte `protobuf:"bytes,2,rep,name=address,proto3" json:"address,omitempty"`
	Value                []byte   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	Script               []byte   `protobuf:"bytes,4,opt,name=script,proto3" json:"script,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Input) Reset()         { *m = Input{} }
func (m *Input) String() string { return proto.CompactTextString(m) }
func (*Input) ProtoMessage()    {}
func (*Input) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{4}
}
func (m *Input) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Input.Unmarshal(m, b)
}
func (m *Input) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Input.Marshal(b, m, deterministic)
}
func (dst *Input) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Input.Merge(dst, src)
}
func (m *Input) XXX_Size() int {
	return xxx_messageInfo_Input.Size(m)
}
func (m *Input) XXX_DiscardUnknown() {
	xxx_messageInfo_Input.DiscardUnknown(m)
}

var xxx_messageInfo_Input proto.InternalMessageInfo

func (m *Input) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *Input) GetAddress() [][]byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Input) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Input) GetScript() []byte {
	if m != nil {
		return m.Script
	}
	return nil
}

type Output struct {
	Index                uint32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Address              []byte   `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Value                []byte   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	Script               []byte   `protobuf:"bytes,4,opt,name=script,proto3" json:"script,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Output) Reset()         { *m = Output{} }
func (m *Output) String() string { return proto.CompactTextString(m) }
func (*Output) ProtoMessage()    {}
func (*Output) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{5}
}
func (m *Output) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Output.Unmarshal(m, b)
}
func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Output.Marshal(b, m, deterministic)
}
func (dst *Output) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Output.Merge(dst, src)
}
func (m *Output) XXX_Size() int {
	return xxx_messageInfo_Output.Size(m)
}
func (m *Output) XXX_DiscardUnknown() {
	xxx_messageInfo_Output.DiscardUnknown(m)
}

var xxx_messageInfo_Output proto.InternalMessageInfo

func (m *Output) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Output) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Output) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Output) GetScript() []byte {
	if m != nil {
		return m.Script
	}
	return nil
}

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{6}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (dst *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(dst, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type SingleBytes struct {
	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SingleBytes) Reset()         { *m = SingleBytes{} }
func (m *SingleBytes) String() string { return proto.CompactTextString(m) }
func (*SingleBytes) ProtoMessage()    {}
func (*SingleBytes) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{7}
}
func (m *SingleBytes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SingleBytes.Unmarshal(m, b)
}
func (m *SingleBytes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SingleBytes.Marshal(b, m, deterministic)
}
func (dst *SingleBytes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleBytes.Merge(dst, src)
}
func (m *SingleBytes) XXX_Size() int {
	return xxx_messageInfo_SingleBytes.Size(m)
}
func (m *SingleBytes) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleBytes.DiscardUnknown(m)
}

var xxx_messageInfo_SingleBytes proto.InternalMessageInfo

func (m *SingleBytes) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type SingleString struct {
	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SingleString) Reset()         { *m = SingleString{} }
func (m *SingleString) String() string { return proto.CompactTextString(m) }
func (*SingleString) ProtoMessage()    {}
func (*SingleString) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{8}
}
func (m *SingleString) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SingleString.Unmarshal(m, b)
}
func (m *SingleString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SingleString.Marshal(b, m, deterministic)
}
func (dst *SingleString) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleString.Merge(dst, src)
}
func (m *SingleString) XXX_Size() int {
	return xxx_messageInfo_SingleString.Size(m)
}
func (m *SingleString) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleString.DiscardUnknown(m)
}

var xxx_messageInfo_SingleString proto.InternalMessageInfo

func (m *SingleString) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type AccountAddress struct {
	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountAddress) Reset()         { *m = AccountAddress{} }
func (m *AccountAddress) String() string { return proto.CompactTextString(m) }
func (*AccountAddress) ProtoMessage()    {}
func (*AccountAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{9}
}
func (m *AccountAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountAddress.Unmarshal(m, b)
}
func (m *AccountAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountAddress.Marshal(b, m, deterministic)
}
func (dst *AccountAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountAddress.Merge(dst, src)
}
func (m *AccountAddress) XXX_Size() int {
	return xxx_messageInfo_AccountAddress.Size(m)
}
func (m *AccountAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountAddress.DiscardUnknown(m)
}

var xxx_messageInfo_AccountAddress proto.InternalMessageInfo

func (m *AccountAddress) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type AccountAndRoot struct {
	Account              []byte   `protobuf:"bytes,1,opt,name=Account,proto3" json:"Account,omitempty"`
	Root                 []byte   `protobuf:"bytes,2,opt,name=Root,proto3" json:"Root,omitempty"`
	Compressed           bool     `protobuf:"varint,3,opt,name=Compressed,proto3" json:"Compressed,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountAndRoot) Reset()         { *m = AccountAndRoot{} }
func (m *AccountAndRoot) String() string { return proto.CompactTextString(m) }
func (*AccountAndRoot) ProtoMessage()    {}
func (*AccountAndRoot) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{10}
}
func (m *AccountAndRoot) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountAndRoot.Unmarshal(m, b)
}
func (m *AccountAndRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountAndRoot.Marshal(b, m, deterministic)
}
func (dst *AccountAndRoot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountAndRoot.Merge(dst, src)
}
func (m *AccountAndRoot) XXX_Size() int {
	return xxx_messageInfo_AccountAndRoot.Size(m)
}
func (m *AccountAndRoot) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountAndRoot.DiscardUnknown(m)
}

var xxx_messageInfo_AccountAndRoot proto.InternalMessageInfo

func (m *AccountAndRoot) GetAccount() []byte {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *AccountAndRoot) GetRoot() []byte {
	if m != nil {
		return m.Root
	}
	return nil
}

func (m *AccountAndRoot) GetCompressed() bool {
	if m != nil {
		return m.Compressed
	}
	return false
}

type Peer struct {
	Address              *PeerAddress    `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Bestblock            *NewBlockNotice `protobuf:"bytes,2,opt,name=bestblock,proto3" json:"bestblock,omitempty"`
	State                int32           `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
	Hidden               bool            `protobuf:"varint,4,opt,name=hidden,proto3" json:"hidden,omitempty"`
	LashCheck            int64           `protobuf:"varint,5,opt,name=lashCheck,proto3" json:"lashCheck,omitempty"`
	Selfpeer             bool            `protobuf:"varint,6,opt,name=selfpeer,proto3" json:"selfpeer,omitempty"`
	Version              string          `protobuf:"bytes,7,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Peer) Reset()         { *m = Peer{} }
func (m *Peer) String() string { return proto.CompactTextString(m) }
func (*Peer) ProtoMessage()    {}
func (*Peer) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{11}
}
func (m *Peer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Peer.Unmarshal(m, b)
}
func (m *Peer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Peer.Marshal(b, m, deterministic)
}
func (dst *Peer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Peer.Merge(dst, src)
}
func (m *Peer) XXX_Size() int {
	return xxx_messageInfo_Peer.Size(m)
}
func (m *Peer) XXX_DiscardUnknown() {
	xxx_messageInfo_Peer.DiscardUnknown(m)
}

var xxx_messageInfo_Peer proto.InternalMessageInfo

func (m *Peer) GetAddress() *PeerAddress {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Peer) GetBestblock() *NewBlockNotice {
	if m != nil {
		return m.Bestblock
	}
	return nil
}

func (m *Peer) GetState() int32 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *Peer) GetHidden() bool {
	if m != nil {
		return m.Hidden
	}
	return false
}

func (m *Peer) GetLashCheck() int64 {
	if m != nil {
		return m.LashCheck
	}
	return 0
}

func (m *Peer) GetSelfpeer() bool {
	if m != nil {
		return m.Selfpeer
	}
	return false
}

func (m *Peer) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type PeerList struct {
	Peers                []*Peer  `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PeerList) Reset()         { *m = PeerList{} }
func (m *PeerList) String() string { return proto.CompactTextString(m) }
func (*PeerList) ProtoMessage()    {}
func (*PeerList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{12}
}
func (m *PeerList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PeerList.Unmarshal(m, b)
}
func (m *PeerList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PeerList.Marshal(b, m, deterministic)
}
func (dst *PeerList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PeerList.Merge(dst, src)
}
func (m *PeerList) XXX_Size() int {
	return xxx_messageInfo_PeerList.Size(m)
}
func (m *PeerList) XXX_DiscardUnknown() {
	xxx_messageInfo_PeerList.DiscardUnknown(m)
}

var xxx_messageInfo_PeerList proto.InternalMessageInfo

func (m *PeerList) GetPeers() []*Peer {
	if m != nil {
		return m.Peers
	}
	return nil
}

type ListParams struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Height               uint64   `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Size                 uint32   `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	Offset               uint32   `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Asc                  bool     `protobuf:"varint,5,opt,name=asc,proto3" json:"asc,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListParams) Reset()         { *m = ListParams{} }
func (m *ListParams) String() string { return proto.CompactTextString(m) }
func (*ListParams) ProtoMessage()    {}
func (*ListParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{13}
}
func (m *ListParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListParams.Unmarshal(m, b)
}
func (m *ListParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListParams.Marshal(b, m, deterministic)
}
func (dst *ListParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListParams.Merge(dst, src)
}
func (m *ListParams) XXX_Size() int {
	return xxx_messageInfo_ListParams.Size(m)
}
func (m *ListParams) XXX_DiscardUnknown() {
	xxx_messageInfo_ListParams.DiscardUnknown(m)
}

var xxx_messageInfo_ListParams proto.InternalMessageInfo

func (m *ListParams) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *ListParams) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *ListParams) GetSize() uint32 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *ListParams) GetOffset() uint32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *ListParams) GetAsc() bool {
	if m != nil {
		return m.Asc
	}
	return false
}

type PageParams struct {
	Offset               uint32   `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	Size                 uint32   `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PageParams) Reset()         { *m = PageParams{} }
func (m *PageParams) String() string { return proto.CompactTextString(m) }
func (*PageParams) ProtoMessage()    {}
func (*PageParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{14}
}
func (m *PageParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PageParams.Unmarshal(m, b)
}
func (m *PageParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PageParams.Marshal(b, m, deterministic)
}
func (dst *PageParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PageParams.Merge(dst, src)
}
func (m *PageParams) XXX_Size() int {
	return xxx_messageInfo_PageParams.Size(m)
}
func (m *PageParams) XXX_DiscardUnknown() {
	xxx_messageInfo_PageParams.DiscardUnknown(m)
}

var xxx_messageInfo_PageParams proto.InternalMessageInfo

func (m *PageParams) GetOffset() uint32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *PageParams) GetSize() uint32 {
	if m != nil {
		return m.Size
	}
	return 0
}

type BlockBodyPaged struct {
	Total                uint32     `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Offset               uint32     `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	Size                 uint32     `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	Body                 *BlockBody `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *BlockBodyPaged) Reset()         { *m = BlockBodyPaged{} }
func (m *BlockBodyPaged) String() string { return proto.CompactTextString(m) }
func (*BlockBodyPaged) ProtoMessage()    {}
func (*BlockBodyPaged) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{15}
}
func (m *BlockBodyPaged) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockBodyPaged.Unmarshal(m, b)
}
func (m *BlockBodyPaged) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockBodyPaged.Marshal(b, m, deterministic)
}
func (dst *BlockBodyPaged) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockBodyPaged.Merge(dst, src)
}
func (m *BlockBodyPaged) XXX_Size() int {
	return xxx_messageInfo_BlockBodyPaged.Size(m)
}
func (m *BlockBodyPaged) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockBodyPaged.DiscardUnknown(m)
}

var xxx_messageInfo_BlockBodyPaged proto.InternalMessageInfo

func (m *BlockBodyPaged) GetTotal() uint32 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *BlockBodyPaged) GetOffset() uint32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *BlockBodyPaged) GetSize() uint32 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *BlockBodyPaged) GetBody() *BlockBody {
	if m != nil {
		return m.Body
	}
	return nil
}

type BlockBodyParams struct {
	Hashornumber         []byte      `protobuf:"bytes,1,opt,name=hashornumber,proto3" json:"hashornumber,omitempty"`
	Paging               *PageParams `protobuf:"bytes,2,opt,name=paging,proto3" json:"paging,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *BlockBodyParams) Reset()         { *m = BlockBodyParams{} }
func (m *BlockBodyParams) String() string { return proto.CompactTextString(m) }
func (*BlockBodyParams) ProtoMessage()    {}
func (*BlockBodyParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{16}
}
func (m *BlockBodyParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockBodyParams.Unmarshal(m, b)
}
func (m *BlockBodyParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockBodyParams.Marshal(b, m, deterministic)
}
func (dst *BlockBodyParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockBodyParams.Merge(dst, src)
}
func (m *BlockBodyParams) XXX_Size() int {
	return xxx_messageInfo_BlockBodyParams.Size(m)
}
func (m *BlockBodyParams) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockBodyParams.DiscardUnknown(m)
}

var xxx_messageInfo_BlockBodyParams proto.InternalMessageInfo

func (m *BlockBodyParams) GetHashornumber() []byte {
	if m != nil {
		return m.Hashornumber
	}
	return nil
}

func (m *BlockBodyParams) GetPaging() *PageParams {
	if m != nil {
		return m.Paging
	}
	return nil
}

type BlockHeaderList struct {
	Blocks               []*Block `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BlockHeaderList) Reset()         { *m = BlockHeaderList{} }
func (m *BlockHeaderList) String() string { return proto.CompactTextString(m) }
func (*BlockHeaderList) ProtoMessage()    {}
func (*BlockHeaderList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{17}
}
func (m *BlockHeaderList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockHeaderList.Unmarshal(m, b)
}
func (m *BlockHeaderList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockHeaderList.Marshal(b, m, deterministic)
}
func (dst *BlockHeaderList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeaderList.Merge(dst, src)
}
func (m *BlockHeaderList) XXX_Size() int {
	return xxx_messageInfo_BlockHeaderList.Size(m)
}
func (m *BlockHeaderList) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeaderList.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeaderList proto.InternalMessageInfo

func (m *BlockHeaderList) GetBlocks() []*Block {
	if m != nil {
		return m.Blocks
	}
	return nil
}

type BlockMetadata struct {
	Hash                 []byte       `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Header               *BlockHeader `protobuf:"bytes,2,opt,name=header,proto3" json:"header,omitempty"`
	Txcount              int32        `protobuf:"varint,3,opt,name=txcount,proto3" json:"txcount,omitempty"`
	Size                 int64        `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *BlockMetadata) Reset()         { *m = BlockMetadata{} }
func (m *BlockMetadata) String() string { return proto.CompactTextString(m) }
func (*BlockMetadata) ProtoMessage()    {}
func (*BlockMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{18}
}
func (m *BlockMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockMetadata.Unmarshal(m, b)
}
func (m *BlockMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockMetadata.Marshal(b, m, deterministic)
}
func (dst *BlockMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockMetadata.Merge(dst, src)
}
func (m *BlockMetadata) XXX_Size() int {
	return xxx_messageInfo_BlockMetadata.Size(m)
}
func (m *BlockMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_BlockMetadata proto.InternalMessageInfo

func (m *BlockMetadata) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *BlockMetadata) GetHeader() *BlockHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *BlockMetadata) GetTxcount() int32 {
	if m != nil {
		return m.Txcount
	}
	return 0
}

func (m *BlockMetadata) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type BlockMetadataList struct {
	Blocks               []*BlockMetadata `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *BlockMetadataList) Reset()         { *m = BlockMetadataList{} }
func (m *BlockMetadataList) String() string { return proto.CompactTextString(m) }
func (*BlockMetadataList) ProtoMessage()    {}
func (*BlockMetadataList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{19}
}
func (m *BlockMetadataList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockMetadataList.Unmarshal(m, b)
}
func (m *BlockMetadataList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockMetadataList.Marshal(b, m, deterministic)
}
func (dst *BlockMetadataList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockMetadataList.Merge(dst, src)
}
func (m *BlockMetadataList) XXX_Size() int {
	return xxx_messageInfo_BlockMetadataList.Size(m)
}
func (m *BlockMetadataList) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockMetadataList.DiscardUnknown(m)
}

var xxx_messageInfo_BlockMetadataList proto.InternalMessageInfo

func (m *BlockMetadataList) GetBlocks() []*BlockMetadata {
	if m != nil {
		return m.Blocks
	}
	return nil
}

type CommitResult struct {
	Hash                 []byte       `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Error                CommitStatus `protobuf:"varint,2,opt,name=error,proto3,enum=types.CommitStatus" json:"error,omitempty"`
	Detail               string       `protobuf:"bytes,3,opt,name=detail,proto3" json:"detail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CommitResult) Reset()         { *m = CommitResult{} }
func (m *CommitResult) String() string { return proto.CompactTextString(m) }
func (*CommitResult) ProtoMessage()    {}
func (*CommitResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{20}
}
func (m *CommitResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitResult.Unmarshal(m, b)
}
func (m *CommitResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitResult.Marshal(b, m, deterministic)
}
func (dst *CommitResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitResult.Merge(dst, src)
}
func (m *CommitResult) XXX_Size() int {
	return xxx_messageInfo_CommitResult.Size(m)
}
func (m *CommitResult) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitResult.DiscardUnknown(m)
}

var xxx_messageInfo_CommitResult proto.InternalMessageInfo

func (m *CommitResult) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *CommitResult) GetError() CommitStatus {
	if m != nil {
		return m.Error
	}
	return CommitStatus_TX_OK
}

func (m *CommitResult) GetDetail() string {
	if m != nil {
		return m.Detail
	}
	return ""
}

type CommitResultList struct {
	Results              []*CommitResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *CommitResultList) Reset()         { *m = CommitResultList{} }
func (m *CommitResultList) String() string { return proto.CompactTextString(m) }
func (*CommitResultList) ProtoMessage()    {}
func (*CommitResultList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{21}
}
func (m *CommitResultList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitResultList.Unmarshal(m, b)
}
func (m *CommitResultList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitResultList.Marshal(b, m, deterministic)
}
func (dst *CommitResultList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitResultList.Merge(dst, src)
}
func (m *CommitResultList) XXX_Size() int {
	return xxx_messageInfo_CommitResultList.Size(m)
}
func (m *CommitResultList) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitResultList.DiscardUnknown(m)
}

var xxx_messageInfo_CommitResultList proto.InternalMessageInfo

func (m *CommitResultList) GetResults() []*CommitResult {
	if m != nil {
		return m.Results
	}
	return nil
}

type VerifyResult struct {
	Tx                   *Tx          `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	Error                VerifyStatus `protobuf:"varint,2,opt,name=error,proto3,enum=types.VerifyStatus" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *VerifyResult) Reset()         { *m = VerifyResult{} }
func (m *VerifyResult) String() string { return proto.CompactTextString(m) }
func (*VerifyResult) ProtoMessage()    {}
func (*VerifyResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{22}
}
func (m *VerifyResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyResult.Unmarshal(m, b)
}
func (m *VerifyResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyResult.Marshal(b, m, deterministic)
}
func (dst *VerifyResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyResult.Merge(dst, src)
}
func (m *VerifyResult) XXX_Size() int {
	return xxx_messageInfo_VerifyResult.Size(m)
}
func (m *VerifyResult) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyResult.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyResult proto.InternalMessageInfo

func (m *VerifyResult) GetTx() *Tx {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *VerifyResult) GetError() VerifyStatus {
	if m != nil {
		return m.Error
	}
	return VerifyStatus_VERIFY_STATUS_OK
}

type Personal struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
	Account              *Account `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Personal) Reset()         { *m = Personal{} }
func (m *Personal) String() string { return proto.CompactTextString(m) }
func (*Personal) ProtoMessage()    {}
func (*Personal) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{23}
}
func (m *Personal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Personal.Unmarshal(m, b)
}
func (m *Personal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Personal.Marshal(b, m, deterministic)
}
func (dst *Personal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Personal.Merge(dst, src)
}
func (m *Personal) XXX_Size() int {
	return xxx_messageInfo_Personal.Size(m)
}
func (m *Personal) XXX_DiscardUnknown() {
	xxx_messageInfo_Personal.DiscardUnknown(m)
}

var xxx_messageInfo_Personal proto.InternalMessageInfo

func (m *Personal) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *Personal) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

type ImportFormat struct {
	Wif                  *SingleBytes `protobuf:"bytes,1,opt,name=wif,proto3" json:"wif,omitempty"`
	Oldpass              string       `protobuf:"bytes,2,opt,name=oldpass,proto3" json:"oldpass,omitempty"`
	Newpass              string       `protobuf:"bytes,3,opt,name=newpass,proto3" json:"newpass,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ImportFormat) Reset()         { *m = ImportFormat{} }
func (m *ImportFormat) String() string { return proto.CompactTextString(m) }
func (*ImportFormat) ProtoMessage()    {}
func (*ImportFormat) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{24}
}
func (m *ImportFormat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ImportFormat.Unmarshal(m, b)
}
func (m *ImportFormat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ImportFormat.Marshal(b, m, deterministic)
}
func (dst *ImportFormat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportFormat.Merge(dst, src)
}
func (m *ImportFormat) XXX_Size() int {
	return xxx_messageInfo_ImportFormat.Size(m)
}
func (m *ImportFormat) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportFormat.DiscardUnknown(m)
}

var xxx_messageInfo_ImportFormat proto.InternalMessageInfo

func (m *ImportFormat) GetWif() *SingleBytes {
	if m != nil {
		return m.Wif
	}
	return nil
}

func (m *ImportFormat) GetOldpass() string {
	if m != nil {
		return m.Oldpass
	}
	return ""
}

func (m *ImportFormat) GetNewpass() string {
	if m != nil {
		return m.Newpass
	}
	return ""
}

type Staking struct {
	Amount               []byte   `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
	When                 uint64   `protobuf:"varint,2,opt,name=when,proto3" json:"when,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Staking) Reset()         { *m = Staking{} }
func (m *Staking) String() string { return proto.CompactTextString(m) }
func (*Staking) ProtoMessage()    {}
func (*Staking) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{25}
}
func (m *Staking) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Staking.Unmarshal(m, b)
}
func (m *Staking) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Staking.Marshal(b, m, deterministic)
}
func (dst *Staking) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Staking.Merge(dst, src)
}
func (m *Staking) XXX_Size() int {
	return xxx_messageInfo_Staking.Size(m)
}
func (m *Staking) XXX_DiscardUnknown() {
	xxx_messageInfo_Staking.DiscardUnknown(m)
}

var xxx_messageInfo_Staking proto.InternalMessageInfo

func (m *Staking) GetAmount() []byte {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *Staking) GetWhen() uint64 {
	if m != nil {
		return m.When
	}
	return 0
}

type Vote struct {
	Candidate            []byte   `protobuf:"bytes,1,opt,name=candidate,proto3" json:"candidate,omitempty"`
	Amount               []byte   `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Vote) Reset()         { *m = Vote{} }
func (m *Vote) String() string { return proto.CompactTextString(m) }
func (*Vote) ProtoMessage()    {}
func (*Vote) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{26}
}
func (m *Vote) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Vote.Unmarshal(m, b)
}
func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Vote.Marshal(b, m, deterministic)
}
func (dst *Vote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vote.Merge(dst, src)
}
func (m *Vote) XXX_Size() int {
	return xxx_messageInfo_Vote.Size(m)
}
func (m *Vote) XXX_DiscardUnknown() {
	xxx_messageInfo_Vote.DiscardUnknown(m)
}

var xxx_messageInfo_Vote proto.InternalMessageInfo

func (m *Vote) GetCandidate() []byte {
	if m != nil {
		return m.Candidate
	}
	return nil
}

func (m *Vote) GetAmount() []byte {
	if m != nil {
		return m.Amount
	}
	return nil
}

type VoteParams struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Count                uint32   `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VoteParams) Reset()         { *m = VoteParams{} }
func (m *VoteParams) String() string { return proto.CompactTextString(m) }
func (*VoteParams) ProtoMessage()    {}
func (*VoteParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{27}
}
func (m *VoteParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VoteParams.Unmarshal(m, b)
}
func (m *VoteParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VoteParams.Marshal(b, m, deterministic)
}
func (dst *VoteParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteParams.Merge(dst, src)
}
func (m *VoteParams) XXX_Size() int {
	return xxx_messageInfo_VoteParams.Size(m)
}
func (m *VoteParams) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteParams.DiscardUnknown(m)
}

var xxx_messageInfo_VoteParams proto.InternalMessageInfo

func (m *VoteParams) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *VoteParams) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type AccountVoteInfo struct {
	Staking              *Staking    `protobuf:"bytes,1,opt,name=staking,proto3" json:"staking,omitempty"`
	Voting               []*VoteInfo `protobuf:"bytes,2,rep,name=voting,proto3" json:"voting,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *AccountVoteInfo) Reset()         { *m = AccountVoteInfo{} }
func (m *AccountVoteInfo) String() string { return proto.CompactTextString(m) }
func (*AccountVoteInfo) ProtoMessage()    {}
func (*AccountVoteInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{28}
}
func (m *AccountVoteInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountVoteInfo.Unmarshal(m, b)
}
func (m *AccountVoteInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountVoteInfo.Marshal(b, m, deterministic)
}
func (dst *AccountVoteInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountVoteInfo.Merge(dst, src)
}
func (m *AccountVoteInfo) XXX_Size() int {
	return xxx_messageInfo_AccountVoteInfo.Size(m)
}
func (m *AccountVoteInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountVoteInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AccountVoteInfo proto.InternalMessageInfo

func (m *AccountVoteInfo) GetStaking() *Staking {
	if m != nil {
		return m.Staking
	}
	return nil
}

func (m *AccountVoteInfo) GetVoting() []*VoteInfo {
	if m != nil {
		return m.Voting
	}
	return nil
}

type VoteInfo struct {
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Candidates           []string `protobuf:"bytes,3,rep,name=candidates,proto3" json:"candidates,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VoteInfo) Reset()         { *m = VoteInfo{} }
func (m *VoteInfo) String() string { return proto.CompactTextString(m) }
func (*VoteInfo) ProtoMessage()    {}
func (*VoteInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{29}
}
func (m *VoteInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VoteInfo.Unmarshal(m, b)
}
func (m *VoteInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VoteInfo.Marshal(b, m, deterministic)
}
func (dst *VoteInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteInfo.Merge(dst, src)
}
func (m *VoteInfo) XXX_Size() int {
	return xxx_messageInfo_VoteInfo.Size(m)
}
func (m *VoteInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteInfo.DiscardUnknown(m)
}

var xxx_messageInfo_VoteInfo proto.InternalMessageInfo

func (m *VoteInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *VoteInfo) GetCandidates() []string {
	if m != nil {
		return m.Candidates
	}
	return nil
}

type VoteList struct {
	Votes                []*Vote  `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VoteList) Reset()         { *m = VoteList{} }
func (m *VoteList) String() string { return proto.CompactTextString(m) }
func (*VoteList) ProtoMessage()    {}
func (*VoteList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{30}
}
func (m *VoteList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VoteList.Unmarshal(m, b)
}
func (m *VoteList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VoteList.Marshal(b, m, deterministic)
}
func (dst *VoteList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteList.Merge(dst, src)
}
func (m *VoteList) XXX_Size() int {
	return xxx_messageInfo_VoteList.Size(m)
}
func (m *VoteList) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteList.DiscardUnknown(m)
}

var xxx_messageInfo_VoteList proto.InternalMessageInfo

func (m *VoteList) GetVotes() []*Vote {
	if m != nil {
		return m.Votes
	}
	return nil
}

func (m *VoteList) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type NodeReq struct {
	Timeout              []byte   `protobuf:"bytes,1,opt,name=timeout,proto3" json:"timeout,omitempty"`
	Component            []byte   `protobuf:"bytes,2,opt,name=component,proto3" json:"component,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeReq) Reset()         { *m = NodeReq{} }
func (m *NodeReq) String() string { return proto.CompactTextString(m) }
func (*NodeReq) ProtoMessage()    {}
func (*NodeReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{31}
}
func (m *NodeReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeReq.Unmarshal(m, b)
}
func (m *NodeReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeReq.Marshal(b, m, deterministic)
}
func (dst *NodeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeReq.Merge(dst, src)
}
func (m *NodeReq) XXX_Size() int {
	return xxx_messageInfo_NodeReq.Size(m)
}
func (m *NodeReq) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeReq.DiscardUnknown(m)
}

var xxx_messageInfo_NodeReq proto.InternalMessageInfo

func (m *NodeReq) GetTimeout() []byte {
	if m != nil {
		return m.Timeout
	}
	return nil
}

func (m *NodeReq) GetComponent() []byte {
	if m != nil {
		return m.Component
	}
	return nil
}

type Name struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	BlockNo              uint64   `protobuf:"varint,2,opt,name=blockNo,proto3" json:"blockNo,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Name) Reset()         { *m = Name{} }
func (m *Name) String() string { return proto.CompactTextString(m) }
func (*Name) ProtoMessage()    {}
func (*Name) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{32}
}
func (m *Name) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Name.Unmarshal(m, b)
}
func (m *Name) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Name.Marshal(b, m, deterministic)
}
func (dst *Name) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Name.Merge(dst, src)
}
func (m *Name) XXX_Size() int {
	return xxx_messageInfo_Name.Size(m)
}
func (m *Name) XXX_DiscardUnknown() {
	xxx_messageInfo_Name.DiscardUnknown(m)
}

var xxx_messageInfo_Name proto.InternalMessageInfo

func (m *Name) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Name) GetBlockNo() uint64 {
	if m != nil {
		return m.BlockNo
	}
	return 0
}

type NameInfo struct {
	Name                 *Name    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Owner                []byte   `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	Destination          []byte   `protobuf:"bytes,3,opt,name=destination,proto3" json:"destination,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NameInfo) Reset()         { *m = NameInfo{} }
func (m *NameInfo) String() string { return proto.CompactTextString(m) }
func (*NameInfo) ProtoMessage()    {}
func (*NameInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{33}
}
func (m *NameInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NameInfo.Unmarshal(m, b)
}
func (m *NameInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NameInfo.Marshal(b, m, deterministic)
}
func (dst *NameInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NameInfo.Merge(dst, src)
}
func (m *NameInfo) XXX_Size() int {
	return xxx_messageInfo_NameInfo.Size(m)
}
func (m *NameInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_NameInfo.DiscardUnknown(m)
}

var xxx_messageInfo_NameInfo proto.InternalMessageInfo

func (m *NameInfo) GetName() *Name {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *NameInfo) GetOwner() []byte {
	if m != nil {
		return m.Owner
	}
	return nil
}

func (m *NameInfo) GetDestination() []byte {
	if m != nil {
		return m.Destination
	}
	return nil
}

type PeersParams struct {
	NoHidden             bool     `protobuf:"varint,1,opt,name=noHidden,proto3" json:"noHidden,omitempty"`
	ShowSelf             bool     `protobuf:"varint,2,opt,name=showSelf,proto3" json:"showSelf,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PeersParams) Reset()         { *m = PeersParams{} }
func (m *PeersParams) String() string { return proto.CompactTextString(m) }
func (*PeersParams) ProtoMessage()    {}
func (*PeersParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{34}
}
func (m *PeersParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PeersParams.Unmarshal(m, b)
}
func (m *PeersParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PeersParams.Marshal(b, m, deterministic)
}
func (dst *PeersParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PeersParams.Merge(dst, src)
}
func (m *PeersParams) XXX_Size() int {
	return xxx_messageInfo_PeersParams.Size(m)
}
func (m *PeersParams) XXX_DiscardUnknown() {
	xxx_messageInfo_PeersParams.DiscardUnknown(m)
}

var xxx_messageInfo_PeersParams proto.InternalMessageInfo

func (m *PeersParams) GetNoHidden() bool {
	if m != nil {
		return m.NoHidden
	}
	return false
}

func (m *PeersParams) GetShowSelf() bool {
	if m != nil {
		return m.ShowSelf
	}
	return false
}

type KeyParams struct {
	Key                  []string `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeyParams) Reset()         { *m = KeyParams{} }
func (m *KeyParams) String() string { return proto.CompactTextString(m) }
func (*KeyParams) ProtoMessage()    {}
func (*KeyParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{35}
}
func (m *KeyParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyParams.Unmarshal(m, b)
}
func (m *KeyParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyParams.Marshal(b, m, deterministic)
}
func (dst *KeyParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyParams.Merge(dst, src)
}
func (m *KeyParams) XXX_Size() int {
	return xxx_messageInfo_KeyParams.Size(m)
}
func (m *KeyParams) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyParams.DiscardUnknown(m)
}

var xxx_messageInfo_KeyParams proto.InternalMessageInfo

func (m *KeyParams) GetKey() []string {
	if m != nil {
		return m.Key
	}
	return nil
}

type ServerInfo struct {
	Status               map[string]string      `protobuf:"bytes,1,rep,name=status,proto3" json:"status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Config               map[string]*ConfigItem `protobuf:"bytes,2,rep,name=config,proto3" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *ServerInfo) Reset()         { *m = ServerInfo{} }
func (m *ServerInfo) String() string { return proto.CompactTextString(m) }
func (*ServerInfo) ProtoMessage()    {}
func (*ServerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{36}
}
func (m *ServerInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerInfo.Unmarshal(m, b)
}
func (m *ServerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerInfo.Marshal(b, m, deterministic)
}
func (dst *ServerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerInfo.Merge(dst, src)
}
func (m *ServerInfo) XXX_Size() int {
	return xxx_messageInfo_ServerInfo.Size(m)
}
func (m *ServerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ServerInfo proto.InternalMessageInfo

func (m *ServerInfo) GetStatus() map[string]string {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ServerInfo) GetConfig() map[string]*ConfigItem {
	if m != nil {
		return m.Config
	}
	return nil
}

type ConfigItem struct {
	Props                map[string]string `protobuf:"bytes,2,rep,name=props,proto3" json:"props,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ConfigItem) Reset()         { *m = ConfigItem{} }
func (m *ConfigItem) String() string { return proto.CompactTextString(m) }
func (*ConfigItem) ProtoMessage()    {}
func (*ConfigItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{37}
}
func (m *ConfigItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfigItem.Unmarshal(m, b)
}
func (m *ConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfigItem.Marshal(b, m, deterministic)
}
func (dst *ConfigItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigItem.Merge(dst, src)
}
func (m *ConfigItem) XXX_Size() int {
	return xxx_messageInfo_ConfigItem.Size(m)
}
func (m *ConfigItem) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigItem.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigItem proto.InternalMessageInfo

func (m *ConfigItem) GetProps() map[string]string {
	if m != nil {
		return m.Props
	}
	return nil
}

type EventList struct {
	Events               []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EventList) Reset()         { *m = EventList{} }
func (m *EventList) String() string { return proto.CompactTextString(m) }
func (*EventList) ProtoMessage()    {}
func (*EventList) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{38}
}
func (m *EventList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventList.Unmarshal(m, b)
}
func (m *EventList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventList.Marshal(b, m, deterministic)
}
func (dst *EventList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventList.Merge(dst, src)
}
func (m *EventList) XXX_Size() int {
	return xxx_messageInfo_EventList.Size(m)
}
func (m *EventList) XXX_DiscardUnknown() {
	xxx_messageInfo_EventList.DiscardUnknown(m)
}

var xxx_messageInfo_EventList proto.InternalMessageInfo

func (m *EventList) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

// info and bps is json string
type ConsensusInfo struct {
	Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	Bps                  []string `protobuf:"bytes,3,rep,name=bps,proto3" json:"bps,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConsensusInfo) Reset()         { *m = ConsensusInfo{} }
func (m *ConsensusInfo) String() string { return proto.CompactTextString(m) }
func (*ConsensusInfo) ProtoMessage()    {}
func (*ConsensusInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{39}
}
func (m *ConsensusInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConsensusInfo.Unmarshal(m, b)
}
func (m *ConsensusInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConsensusInfo.Marshal(b, m, deterministic)
}
func (dst *ConsensusInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConsensusInfo.Merge(dst, src)
}
func (m *ConsensusInfo) XXX_Size() int {
	return xxx_messageInfo_ConsensusInfo.Size(m)
}
func (m *ConsensusInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ConsensusInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ConsensusInfo proto.InternalMessageInfo

func (m *ConsensusInfo) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ConsensusInfo) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *ConsensusInfo) GetBps() []string {
	if m != nil {
		return m.Bps
	}
	return nil
}

type EnterpriseConfigKey struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EnterpriseConfigKey) Reset()         { *m = EnterpriseConfigKey{} }
func (m *EnterpriseConfigKey) String() string { return proto.CompactTextString(m) }
func (*EnterpriseConfigKey) ProtoMessage()    {}
func (*EnterpriseConfigKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{40}
}
func (m *EnterpriseConfigKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EnterpriseConfigKey.Unmarshal(m, b)
}
func (m *EnterpriseConfigKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EnterpriseConfigKey.Marshal(b, m, deterministic)
}
func (dst *EnterpriseConfigKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnterpriseConfigKey.Merge(dst, src)
}
func (m *EnterpriseConfigKey) XXX_Size() int {
	return xxx_messageInfo_EnterpriseConfigKey.Size(m)
}
func (m *EnterpriseConfigKey) XXX_DiscardUnknown() {
	xxx_messageInfo_EnterpriseConfigKey.DiscardUnknown(m)
}

var xxx_messageInfo_EnterpriseConfigKey proto.InternalMessageInfo

func (m *EnterpriseConfigKey) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type EnterpriseConfig struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	On                   bool     `protobuf:"varint,2,opt,name=on,proto3" json:"on,omitempty"`
	Values               []string `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EnterpriseConfig) Reset()         { *m = EnterpriseConfig{} }
func (m *EnterpriseConfig) String() string { return proto.CompactTextString(m) }
func (*EnterpriseConfig) ProtoMessage()    {}
func (*EnterpriseConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_rpc_ad055011a3c10f82, []int{41}
}
func (m *EnterpriseConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EnterpriseConfig.Unmarshal(m, b)
}
func (m *EnterpriseConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EnterpriseConfig.Marshal(b, m, deterministic)
}
func (dst *EnterpriseConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnterpriseConfig.Merge(dst, src)
}
func (m *EnterpriseConfig) XXX_Size() int {
	return xxx_messageInfo_EnterpriseConfig.Size(m)
}
func (m *EnterpriseConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_EnterpriseConfig.DiscardUnknown(m)
}

var xxx_messageInfo_EnterpriseConfig proto.InternalMessageInfo

func (m *EnterpriseConfig) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *EnterpriseConfig) GetOn() bool {
	if m != nil {
		return m.On
	}
	return false
}

func (m *EnterpriseConfig) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

func init() {
	proto.RegisterType((*BlockchainStatus)(nil), "types.BlockchainStatus")
	proto.RegisterType((*ChainId)(nil), "types.ChainId")
	proto.RegisterType((*ChainInfo)(nil), "types.ChainInfo")
	proto.RegisterType((*ChainStats)(nil), "types.ChainStats")
	proto.RegisterType((*Input)(nil), "types.Input")
	proto.RegisterType((*Output)(nil), "types.Output")
	proto.RegisterType((*Empty)(nil), "types.Empty")
	proto.RegisterType((*SingleBytes)(nil), "types.SingleBytes")
	proto.RegisterType((*SingleString)(nil), "types.SingleString")
	proto.RegisterType((*AccountAddress)(nil), "types.AccountAddress")
	proto.RegisterType((*AccountAndRoot)(nil), "types.AccountAndRoot")
	proto.RegisterType((*Peer)(nil), "types.Peer")
	proto.RegisterType((*PeerList)(nil), "types.PeerList")
	proto.RegisterType((*ListParams)(nil), "types.ListParams")
	proto.RegisterType((*PageParams)(nil), "types.PageParams")
	proto.RegisterType((*BlockBodyPaged)(nil), "types.BlockBodyPaged")
	proto.RegisterType((*BlockBodyParams)(nil), "types.BlockBodyParams")
	proto.RegisterType((*BlockHeaderList)(nil), "types.BlockHeaderList")
	proto.RegisterType((*BlockMetadata)(nil), "types.BlockMetadata")
	proto.RegisterType((*BlockMetadataList)(nil), "types.BlockMetadataList")
	proto.RegisterType((*CommitResult)(nil), "types.CommitResult")
	proto.RegisterType((*CommitResultList)(nil), "types.CommitResultList")
	proto.RegisterType((*VerifyResult)(nil), "types.VerifyResult")
	proto.RegisterType((*Personal)(nil), "types.Personal")
	proto.RegisterType((*ImportFormat)(nil), "types.ImportFormat")
	proto.RegisterType((*Staking)(nil), "types.Staking")
	proto.RegisterType((*Vote)(nil), "types.Vote")
	proto.RegisterType((*VoteParams)(nil), "types.VoteParams")
	proto.RegisterType((*AccountVoteInfo)(nil), "types.AccountVoteInfo")
	proto.RegisterType((*VoteInfo)(nil), "types.VoteInfo")
	proto.RegisterType((*VoteList)(nil), "types.VoteList")
	proto.RegisterType((*NodeReq)(nil), "types.NodeReq")
	proto.RegisterType((*Name)(nil), "types.Name")
	proto.RegisterType((*NameInfo)(nil), "types.NameInfo")
	proto.RegisterType((*PeersParams)(nil), "types.PeersParams")
	proto.RegisterType((*KeyParams)(nil), "types.KeyParams")
	proto.RegisterType((*ServerInfo)(nil), "types.ServerInfo")
	proto.RegisterMapType((map[string]*ConfigItem)(nil), "types.ServerInfo.ConfigEntry")
	proto.RegisterMapType((map[string]string)(nil), "types.ServerInfo.StatusEntry")
	proto.RegisterType((*ConfigItem)(nil), "types.ConfigItem")
	proto.RegisterMapType((map[string]string)(nil), "types.ConfigItem.PropsEntry")
	proto.RegisterType((*EventList)(nil), "types.EventList")
	proto.RegisterType((*ConsensusInfo)(nil), "types.ConsensusInfo")
	proto.RegisterType((*EnterpriseConfigKey)(nil), "types.EnterpriseConfigKey")
	proto.RegisterType((*EnterpriseConfig)(nil), "types.EnterpriseConfig")
	proto.RegisterEnum("types.CommitStatus", CommitStatus_name, CommitStatus_value)
	proto.RegisterEnum("types.VerifyStatus", VerifyStatus_name, VerifyStatus_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.SupportPackageIsVersion4

// AergoRPCServiceClient is the client API for AergoRPCService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AergoRPCServiceClient interface {
	// Returns the current state of this node
	NodeState(ctx context.Context, in *NodeReq, opts ...grpc.CallOption) (*SingleBytes, error)
	// Returns node metrics according to request
	Metric(ctx context.Context, in *MetricsRequest, opts ...grpc.CallOption) (*Metrics, error)
	// Returns current blockchain status (best block's height and hash)
	Blockchain(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*BlockchainStatus, error)
	// Returns current blockchain's basic information
	GetChainInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainInfo, error)
	// Returns current chain statistics
	ChainStat(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainStats, error)
	// Returns list of Blocks without body according to request
	ListBlockHeaders(ctx context.Context, in *ListParams, opts ...grpc.CallOption) (*BlockHeaderList, error)
	// Returns list of block metadata (hash, header, and number of transactions) according to request
	ListBlockMetadata(ctx context.Context, in *ListParams, opts ...grpc.CallOption) (*BlockMetadataList, error)
	// Returns a stream of new blocks as they get added to the blockchain
	ListBlockStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AergoRPCService_ListBlockStreamClient, error)
	// Returns a stream of new block's metadata as they get added to the blockchain
	ListBlockMetadataStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AergoRPCService_ListBlockMetadataStreamClient, error)
	// Return a single block incl. header and body, queried by hash or number
	GetBlock(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Block, error)
	// Return a single block's metdata (hash, header, and number of transactions), queried by hash or number
	GetBlockMetadata(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*BlockMetadata, error)
	// Return a single block's body, queried by hash or number and list parameters
	GetBlockBody(ctx context.Context, in *BlockBodyParams, opts ...grpc.CallOption) (*BlockBodyPaged, error)
	// Return a single transaction, queried by transaction hash
	GetTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Tx, error)
	// Return information about transaction in block, queried by transaction hash
	GetBlockTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*TxInBlock, error)
	// Return transaction receipt, queried by transaction hash
	GetReceipt(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Receipt, error)
	// Return ABI stored at contract address
	GetABI(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*ABI, error)
	// Sign and send a transaction from an unlocked account
	SendTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*CommitResult, error)
	// Sign transaction with unlocked account
	SignTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*Tx, error)
	// Verify validity of transaction
	VerifyTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*VerifyResult, error)
	// Commit a signed transaction
	CommitTX(ctx context.Context, in *TxList, opts ...grpc.CallOption) (*CommitResultList, error)
	// Return state of account
	GetState(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*State, error)
	// Return state of account, including merkle proof
	GetStateAndProof(ctx context.Context, in *AccountAndRoot, opts ...grpc.CallOption) (*AccountProof, error)
	// Create a new account in this node
	CreateAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	// Return list of accounts in this node
	GetAccounts(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*AccountList, error)
	// Lock account in this node
	LockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	// Unlock account in this node
	UnlockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	// Import account to this node
	ImportAccount(ctx context.Context, in *ImportFormat, opts ...grpc.CallOption) (*Account, error)
	// Export account stored in this node
	ExportAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*SingleBytes, error)
	// Query a contract method
	QueryContract(ctx context.Context, in *Query, opts ...grpc.CallOption) (*SingleBytes, error)
	// Query contract state
	QueryContractState(ctx context.Context, in *StateQuery, opts ...grpc.CallOption) (*StateQueryProof, error)
	// Return list of peers of this node and their state
	GetPeers(ctx context.Context, in *PeersParams, opts ...grpc.CallOption) (*PeerList, error)
	// Return result of vote
	GetVotes(ctx context.Context, in *VoteParams, opts ...grpc.CallOption) (*VoteList, error)
	// Return staking, voting info for account
	GetAccountVotes(ctx context.Context, in *AccountAddress, opts ...grpc.CallOption) (*AccountVoteInfo, error)
	// Return staking information
	GetStaking(ctx context.Context, in *AccountAddress, opts ...grpc.CallOption) (*Staking, error)
	// Return name information
	GetNameInfo(ctx context.Context, in *Name, opts ...grpc.CallOption) (*NameInfo, error)
	// Returns a stream of event as they get added to the blockchain
	ListEventStream(ctx context.Context, in *FilterInfo, opts ...grpc.CallOption) (AergoRPCService_ListEventStreamClient, error)
	// Returns list of event
	ListEvents(ctx context.Context, in *FilterInfo, opts ...grpc.CallOption) (*EventList, error)
	// Returns configs and statuses of server
	GetServerInfo(ctx context.Context, in *KeyParams, opts ...grpc.CallOption) (*ServerInfo, error)
	// Returns status of consensus and bps
	GetConsensusInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConsensusInfo, error)
	// Add & remove member of raft cluster
	ChangeMembership(ctx context.Context, in *MembershipChange, opts ...grpc.CallOption) (*MembershipChangeReply, error)
	// Returns enterprise config
	GetEnterpriseConfig(ctx context.Context, in *EnterpriseConfigKey, opts ...grpc.CallOption) (*EnterpriseConfig, error)
	// Return a status of changeCluster enterprise tx,  queried by requestID
	GetConfChangeProgress(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*ConfChangeProgress, error)
}

type aergoRPCServiceClient struct {
	cc *grpc.ClientConn
}

func NewAergoRPCServiceClient(cc *grpc.ClientConn) AergoRPCServiceClient {
	return &aergoRPCServiceClient{cc}
}

func (c *aergoRPCServiceClient) NodeState(ctx context.Context, in *NodeReq, opts ...grpc.CallOption) (*SingleBytes, error) {
	out := new(SingleBytes)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/NodeState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) Metric(ctx context.Context, in *MetricsRequest, opts ...grpc.CallOption) (*Metrics, error) {
	out := new(Metrics)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/Metric", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) Blockchain(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*BlockchainStatus, error) {
	out := new(BlockchainStatus)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/Blockchain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetChainInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainInfo, error) {
	out := new(ChainInfo)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetChainInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ChainStat(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainStats, error) {
	out := new(ChainStats)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ChainStat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ListBlockHeaders(ctx context.Context, in *ListParams, opts ...grpc.CallOption) (*BlockHeaderList, error) {
	out := new(BlockHeaderList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ListBlockHeaders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ListBlockMetadata(ctx context.Context, in *ListParams, opts ...grpc.CallOption) (*BlockMetadataList, error) {
	out := new(BlockMetadataList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ListBlockMetadata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ListBlockStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AergoRPCService_ListBlockStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AergoRPCService_serviceDesc.Streams[0], "/types.AergoRPCService/ListBlockStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &aergoRPCServiceListBlockStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AergoRPCService_ListBlockStreamClient interface {
	Recv() (*Block, error)
	grpc.ClientStream
}

type aergoRPCServiceListBlockStreamClient struct {
	grpc.ClientStream
}

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

func (c *aergoRPCServiceClient) ListBlockMetadataStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AergoRPCService_ListBlockMetadataStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AergoRPCService_serviceDesc.Streams[1], "/types.AergoRPCService/ListBlockMetadataStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &aergoRPCServiceListBlockMetadataStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AergoRPCService_ListBlockMetadataStreamClient interface {
	Recv() (*BlockMetadata, error)
	grpc.ClientStream
}

type aergoRPCServiceListBlockMetadataStreamClient struct {
	grpc.ClientStream
}

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

func (c *aergoRPCServiceClient) GetBlock(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Block, error) {
	out := new(Block)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetBlockMetadata(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*BlockMetadata, error) {
	out := new(BlockMetadata)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetBlockMetadata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetBlockBody(ctx context.Context, in *BlockBodyParams, opts ...grpc.CallOption) (*BlockBodyPaged, error) {
	out := new(BlockBodyPaged)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetBlockBody", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Tx, error) {
	out := new(Tx)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetBlockTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*TxInBlock, error) {
	out := new(TxInBlock)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetBlockTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetReceipt(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Receipt, error) {
	out := new(Receipt)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetReceipt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetABI(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*ABI, error) {
	out := new(ABI)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetABI", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) SendTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*CommitResult, error) {
	out := new(CommitResult)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/SendTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) SignTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*Tx, error) {
	out := new(Tx)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/SignTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) VerifyTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*VerifyResult, error) {
	out := new(VerifyResult)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/VerifyTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) CommitTX(ctx context.Context, in *TxList, opts ...grpc.CallOption) (*CommitResultList, error) {
	out := new(CommitResultList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/CommitTX", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetState(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*State, error) {
	out := new(State)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetStateAndProof(ctx context.Context, in *AccountAndRoot, opts ...grpc.CallOption) (*AccountProof, error) {
	out := new(AccountProof)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetStateAndProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) CreateAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error) {
	out := new(Account)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/CreateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetAccounts(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*AccountList, error) {
	out := new(AccountList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetAccounts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) LockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error) {
	out := new(Account)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/LockAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) UnlockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error) {
	out := new(Account)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/UnlockAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ImportAccount(ctx context.Context, in *ImportFormat, opts ...grpc.CallOption) (*Account, error) {
	out := new(Account)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ImportAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ExportAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*SingleBytes, error) {
	out := new(SingleBytes)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ExportAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) QueryContract(ctx context.Context, in *Query, opts ...grpc.CallOption) (*SingleBytes, error) {
	out := new(SingleBytes)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/QueryContract", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) QueryContractState(ctx context.Context, in *StateQuery, opts ...grpc.CallOption) (*StateQueryProof, error) {
	out := new(StateQueryProof)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/QueryContractState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetPeers(ctx context.Context, in *PeersParams, opts ...grpc.CallOption) (*PeerList, error) {
	out := new(PeerList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetVotes(ctx context.Context, in *VoteParams, opts ...grpc.CallOption) (*VoteList, error) {
	out := new(VoteList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetVotes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetAccountVotes(ctx context.Context, in *AccountAddress, opts ...grpc.CallOption) (*AccountVoteInfo, error) {
	out := new(AccountVoteInfo)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetAccountVotes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetStaking(ctx context.Context, in *AccountAddress, opts ...grpc.CallOption) (*Staking, error) {
	out := new(Staking)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetStaking", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetNameInfo(ctx context.Context, in *Name, opts ...grpc.CallOption) (*NameInfo, error) {
	out := new(NameInfo)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetNameInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ListEventStream(ctx context.Context, in *FilterInfo, opts ...grpc.CallOption) (AergoRPCService_ListEventStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AergoRPCService_serviceDesc.Streams[2], "/types.AergoRPCService/ListEventStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &aergoRPCServiceListEventStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AergoRPCService_ListEventStreamClient interface {
	Recv() (*Event, error)
	grpc.ClientStream
}

type aergoRPCServiceListEventStreamClient struct {
	grpc.ClientStream
}

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

func (c *aergoRPCServiceClient) ListEvents(ctx context.Context, in *FilterInfo, opts ...grpc.CallOption) (*EventList, error) {
	out := new(EventList)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ListEvents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetServerInfo(ctx context.Context, in *KeyParams, opts ...grpc.CallOption) (*ServerInfo, error) {
	out := new(ServerInfo)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetServerInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetConsensusInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConsensusInfo, error) {
	out := new(ConsensusInfo)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetConsensusInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) ChangeMembership(ctx context.Context, in *MembershipChange, opts ...grpc.CallOption) (*MembershipChangeReply, error) {
	out := new(MembershipChangeReply)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/ChangeMembership", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetEnterpriseConfig(ctx context.Context, in *EnterpriseConfigKey, opts ...grpc.CallOption) (*EnterpriseConfig, error) {
	out := new(EnterpriseConfig)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetEnterpriseConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aergoRPCServiceClient) GetConfChangeProgress(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*ConfChangeProgress, error) {
	out := new(ConfChangeProgress)
	err := c.cc.Invoke(ctx, "/types.AergoRPCService/GetConfChangeProgress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AergoRPCServiceServer is the server API for AergoRPCService service.
type AergoRPCServiceServer interface {
	// Returns the current state of this node
	NodeState(context.Context, *NodeReq) (*SingleBytes, error)
	// Returns node metrics according to request
	Metric(context.Context, *MetricsRequest) (*Metrics, error)
	// Returns current blockchain status (best block's height and hash)
	Blockchain(context.Context, *Empty) (*BlockchainStatus, error)
	// Returns current blockchain's basic information
	GetChainInfo(context.Context, *Empty) (*ChainInfo, error)
	// Returns current chain statistics
	ChainStat(context.Context, *Empty) (*ChainStats, error)
	// Returns list of Blocks without body according to request
	ListBlockHeaders(context.Context, *ListParams) (*BlockHeaderList, error)
	// Returns list of block metadata (hash, header, and number of transactions) according to request
	ListBlockMetadata(context.Context, *ListParams) (*BlockMetadataList, error)
	// Returns a stream of new blocks as they get added to the blockchain
	ListBlockStream(*Empty, AergoRPCService_ListBlockStreamServer) error
	// Returns a stream of new block's metadata as they get added to the blockchain
	ListBlockMetadataStream(*Empty, AergoRPCService_ListBlockMetadataStreamServer) error
	// Return a single block incl. header and body, queried by hash or number
	GetBlock(context.Context, *SingleBytes) (*Block, error)
	// Return a single block's metdata (hash, header, and number of transactions), queried by hash or number
	GetBlockMetadata(context.Context, *SingleBytes) (*BlockMetadata, error)
	// Return a single block's body, queried by hash or number and list parameters
	GetBlockBody(context.Context, *BlockBodyParams) (*BlockBodyPaged, error)
	// Return a single transaction, queried by transaction hash
	GetTX(context.Context, *SingleBytes) (*Tx, error)
	// Return information about transaction in block, queried by transaction hash
	GetBlockTX(context.Context, *SingleBytes) (*TxInBlock, error)
	// Return transaction receipt, queried by transaction hash
	GetReceipt(context.Context, *SingleBytes) (*Receipt, error)
	// Return ABI stored at contract address
	GetABI(context.Context, *SingleBytes) (*ABI, error)
	// Sign and send a transaction from an unlocked account
	SendTX(context.Context, *Tx) (*CommitResult, error)
	// Sign transaction with unlocked account
	SignTX(context.Context, *Tx) (*Tx, error)
	// Verify validity of transaction
	VerifyTX(context.Context, *Tx) (*VerifyResult, error)
	// Commit a signed transaction
	CommitTX(context.Context, *TxList) (*CommitResultList, error)
	// Return state of account
	GetState(context.Context, *SingleBytes) (*State, error)
	// Return state of account, including merkle proof
	GetStateAndProof(context.Context, *AccountAndRoot) (*AccountProof, error)
	// Create a new account in this node
	CreateAccount(context.Context, *Personal) (*Account, error)
	// Return list of accounts in this node
	GetAccounts(context.Context, *Empty) (*AccountList, error)
	// Lock account in this node
	LockAccount(context.Context, *Personal) (*Account, error)
	// Unlock account in this node
	UnlockAccount(context.Context, *Personal) (*Account, error)
	// Import account to this node
	ImportAccount(context.Context, *ImportFormat) (*Account, error)
	// Export account stored in this node
	ExportAccount(context.Context, *Personal) (*SingleBytes, error)
	// Query a contract method
	QueryContract(context.Context, *Query) (*SingleBytes, error)
	// Query contract state
	QueryContractState(context.Context, *StateQuery) (*StateQueryProof, error)
	// Return list of peers of this node and their state
	GetPeers(context.Context, *PeersParams) (*PeerList, error)
	// Return result of vote
	GetVotes(context.Context, *VoteParams) (*VoteList, error)
	// Return staking, voting info for account
	GetAccountVotes(context.Context, *AccountAddress) (*AccountVoteInfo, error)
	// Return staking information
	GetStaking(context.Context, *AccountAddress) (*Staking, error)
	// Return name information
	GetNameInfo(context.Context, *Name) (*NameInfo, error)
	// Returns a stream of event as they get added to the blockchain
	ListEventStream(*FilterInfo, AergoRPCService_ListEventStreamServer) error
	// Returns list of event
	ListEvents(context.Context, *FilterInfo) (*EventList, error)
	// Returns configs and statuses of server
	GetServerInfo(context.Context, *KeyParams) (*ServerInfo, error)
	// Returns status of consensus and bps
	GetConsensusInfo(context.Context, *Empty) (*ConsensusInfo, error)
	// Add & remove member of raft cluster
	ChangeMembership(context.Context, *MembershipChange) (*MembershipChangeReply, error)
	// Returns enterprise config
	GetEnterpriseConfig(context.Context, *EnterpriseConfigKey) (*EnterpriseConfig, error)
	// Return a status of changeCluster enterprise tx,  queried by requestID
	GetConfChangeProgress(context.Context, *SingleBytes) (*ConfChangeProgress, error)
}

func RegisterAergoRPCServiceServer(s *grpc.Server, srv AergoRPCServiceServer) {
	s.RegisterService(&_AergoRPCService_serviceDesc, srv)
}

func _AergoRPCService_NodeState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).NodeState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/NodeState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).NodeState(ctx, req.(*NodeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_Metric_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MetricsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).Metric(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/Metric",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).Metric(ctx, req.(*MetricsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_Blockchain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).Blockchain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/Blockchain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).Blockchain(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetChainInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetChainInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetChainInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetChainInfo(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ChainStat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ChainStat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ChainStat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ChainStat(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ListBlockHeaders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ListBlockHeaders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ListBlockHeaders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ListBlockHeaders(ctx, req.(*ListParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ListBlockMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ListBlockMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ListBlockMetadata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ListBlockMetadata(ctx, req.(*ListParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ListBlockStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AergoRPCServiceServer).ListBlockStream(m, &aergoRPCServiceListBlockStreamServer{stream})
}

type AergoRPCService_ListBlockStreamServer interface {
	Send(*Block) error
	grpc.ServerStream
}

type aergoRPCServiceListBlockStreamServer struct {
	grpc.ServerStream
}

func (x *aergoRPCServiceListBlockStreamServer) Send(m *Block) error {
	return x.ServerStream.SendMsg(m)
}

func _AergoRPCService_ListBlockMetadataStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AergoRPCServiceServer).ListBlockMetadataStream(m, &aergoRPCServiceListBlockMetadataStreamServer{stream})
}

type AergoRPCService_ListBlockMetadataStreamServer interface {
	Send(*BlockMetadata) error
	grpc.ServerStream
}

type aergoRPCServiceListBlockMetadataStreamServer struct {
	grpc.ServerStream
}

func (x *aergoRPCServiceListBlockMetadataStreamServer) Send(m *BlockMetadata) error {
	return x.ServerStream.SendMsg(m)
}

func _AergoRPCService_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetBlock(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetBlockMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetBlockMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetBlockMetadata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetBlockMetadata(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetBlockBody_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockBodyParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetBlockBody(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetBlockBody",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetBlockBody(ctx, req.(*BlockBodyParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetTX(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetBlockTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetBlockTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetBlockTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetBlockTX(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetReceipt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetReceipt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetReceipt(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetABI_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetABI(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetABI",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetABI(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_SendTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Tx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).SendTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/SendTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).SendTX(ctx, req.(*Tx))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_SignTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Tx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).SignTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/SignTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).SignTX(ctx, req.(*Tx))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_VerifyTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Tx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).VerifyTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/VerifyTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).VerifyTX(ctx, req.(*Tx))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_CommitTX_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TxList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).CommitTX(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/CommitTX",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).CommitTX(ctx, req.(*TxList))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetState(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetStateAndProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountAndRoot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetStateAndProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetStateAndProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetStateAndProof(ctx, req.(*AccountAndRoot))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_CreateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Personal)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).CreateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/CreateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).CreateAccount(ctx, req.(*Personal))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetAccounts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetAccounts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetAccounts(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_LockAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Personal)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).LockAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/LockAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).LockAccount(ctx, req.(*Personal))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_UnlockAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Personal)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).UnlockAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/UnlockAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).UnlockAccount(ctx, req.(*Personal))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ImportAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportFormat)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ImportAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ImportAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ImportAccount(ctx, req.(*ImportFormat))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ExportAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Personal)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ExportAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ExportAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ExportAccount(ctx, req.(*Personal))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_QueryContract_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.(AergoRPCServiceServer).QueryContract(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/QueryContract",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).QueryContract(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_QueryContractState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StateQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).QueryContractState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/QueryContractState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).QueryContractState(ctx, req.(*StateQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PeersParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetPeers(ctx, req.(*PeersParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetVotes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VoteParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetVotes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetVotes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetVotes(ctx, req.(*VoteParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetAccountVotes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountAddress)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetAccountVotes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetAccountVotes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetAccountVotes(ctx, req.(*AccountAddress))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetStaking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountAddress)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetStaking(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetStaking",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetStaking(ctx, req.(*AccountAddress))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetNameInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Name)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetNameInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetNameInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetNameInfo(ctx, req.(*Name))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ListEventStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FilterInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AergoRPCServiceServer).ListEventStream(m, &aergoRPCServiceListEventStreamServer{stream})
}

type AergoRPCService_ListEventStreamServer interface {
	Send(*Event) error
	grpc.ServerStream
}

type aergoRPCServiceListEventStreamServer struct {
	grpc.ServerStream
}

func (x *aergoRPCServiceListEventStreamServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

func _AergoRPCService_ListEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FilterInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ListEvents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ListEvents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ListEvents(ctx, req.(*FilterInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetServerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetServerInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetServerInfo(ctx, req.(*KeyParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetConsensusInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetConsensusInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetConsensusInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetConsensusInfo(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_ChangeMembership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MembershipChange)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).ChangeMembership(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/ChangeMembership",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).ChangeMembership(ctx, req.(*MembershipChange))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetEnterpriseConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnterpriseConfigKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetEnterpriseConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetEnterpriseConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetEnterpriseConfig(ctx, req.(*EnterpriseConfigKey))
	}
	return interceptor(ctx, in, info, handler)
}

func _AergoRPCService_GetConfChangeProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleBytes)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AergoRPCServiceServer).GetConfChangeProgress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.AergoRPCService/GetConfChangeProgress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AergoRPCServiceServer).GetConfChangeProgress(ctx, req.(*SingleBytes))
	}
	return interceptor(ctx, in, info, handler)
}

var _AergoRPCService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.AergoRPCService",
	HandlerType: (*AergoRPCServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "NodeState",
			Handler:    _AergoRPCService_NodeState_Handler,
		},
		{
			MethodName: "Metric",
			Handler:    _AergoRPCService_Metric_Handler,
		},
		{
			MethodName: "Blockchain",
			Handler:    _AergoRPCService_Blockchain_Handler,
		},
		{
			MethodName: "GetChainInfo",
			Handler:    _AergoRPCService_GetChainInfo_Handler,
		},
		{
			MethodName: "ChainStat",
			Handler:    _AergoRPCService_ChainStat_Handler,
		},
		{
			MethodName: "ListBlockHeaders",
			Handler:    _AergoRPCService_ListBlockHeaders_Handler,
		},
		{
			MethodName: "ListBlockMetadata",
			Handler:    _AergoRPCService_ListBlockMetadata_Handler,
		},
		{
			MethodName: "GetBlock",
			Handler:    _AergoRPCService_GetBlock_Handler,
		},
		{
			MethodName: "GetBlockMetadata",
			Handler:    _AergoRPCService_GetBlockMetadata_Handler,
		},
		{
			MethodName: "GetBlockBody",
			Handler:    _AergoRPCService_GetBlockBody_Handler,
		},
		{
			MethodName: "GetTX",
			Handler:    _AergoRPCService_GetTX_Handler,
		},
		{
			MethodName: "GetBlockTX",
			Handler:    _AergoRPCService_GetBlockTX_Handler,
		},
		{
			MethodName: "GetReceipt",
			Handler:    _AergoRPCService_GetReceipt_Handler,
		},
		{
			MethodName: "GetABI",
			Handler:    _AergoRPCService_GetABI_Handler,
		},
		{
			MethodName: "SendTX",
			Handler:    _AergoRPCService_SendTX_Handler,
		},
		{
			MethodName: "SignTX",
			Handler:    _AergoRPCService_SignTX_Handler,
		},
		{
			MethodName: "VerifyTX",
			Handler:    _AergoRPCService_VerifyTX_Handler,
		},
		{
			MethodName: "CommitTX",
			Handler:    _AergoRPCService_CommitTX_Handler,
		},
		{
			MethodName: "GetState",
			Handler:    _AergoRPCService_GetState_Handler,
		},
		{
			MethodName: "GetStateAndProof",
			Handler:    _AergoRPCService_GetStateAndProof_Handler,
		},
		{
			MethodName: "CreateAccount",
			Handler:    _AergoRPCService_CreateAccount_Handler,
		},
		{
			MethodName: "GetAccounts",
			Handler:    _AergoRPCService_GetAccounts_Handler,
		},
		{
			MethodName: "LockAccount",
			Handler:    _AergoRPCService_LockAccount_Handler,
		},
		{
			MethodName: "UnlockAccount",
			Handler:    _AergoRPCService_UnlockAccount_Handler,
		},
		{
			MethodName: "ImportAccount",
			Handler:    _AergoRPCService_ImportAccount_Handler,
		},
		{
			MethodName: "ExportAccount",
			Handler:    _AergoRPCService_ExportAccount_Handler,
		},
		{
			MethodName: "QueryContract",
			Handler:    _AergoRPCService_QueryContract_Handler,
		},
		{
			MethodName: "QueryContractState",
			Handler:    _AergoRPCService_QueryContractState_Handler,
		},
		{
			MethodName: "GetPeers",
			Handler:    _AergoRPCService_GetPeers_Handler,
		},
		{
			MethodName: "GetVotes",
			Handler:    _AergoRPCService_GetVotes_Handler,
		},
		{
			MethodName: "GetAccountVotes",
			Handler:    _AergoRPCService_GetAccountVotes_Handler,
		},
		{
			MethodName: "GetStaking",
			Handler:    _AergoRPCService_GetStaking_Handler,
		},
		{
			MethodName: "GetNameInfo",
			Handler:    _AergoRPCService_GetNameInfo_Handler,
		},
		{
			MethodName: "ListEvents",
			Handler:    _AergoRPCService_ListEvents_Handler,
		},
		{
			MethodName: "GetServerInfo",
			Handler:    _AergoRPCService_GetServerInfo_Handler,
		},
		{
			MethodName: "GetConsensusInfo",
			Handler:    _AergoRPCService_GetConsensusInfo_Handler,
		},
		{
			MethodName: "ChangeMembership",
			Handler:    _AergoRPCService_ChangeMembership_Handler,
		},
		{
			MethodName: "GetEnterpriseConfig",
			Handler:    _AergoRPCService_GetEnterpriseConfig_Handler,
		},
		{
			MethodName: "GetConfChangeProgress",
			Handler:    _AergoRPCService_GetConfChangeProgress_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListBlockStream",
			Handler:       _AergoRPCService_ListBlockStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListBlockMetadataStream",
			Handler:       _AergoRPCService_ListBlockMetadataStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListEventStream",
			Handler:       _AergoRPCService_ListEventStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpc.proto",
}

func init() { proto.RegisterFile("rpc.proto", fileDescriptor_rpc_ad055011a3c10f82) }

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