rpc.pb.go

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

package types

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

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

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_77a6da22d6a3feb1, []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_77a6da22d6a3feb1, []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"`
	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_77a6da22d6a3feb1, []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 (m *BlockchainStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockchainStatus.Merge(m, 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
}

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_77a6da22d6a3feb1, []int{1}
}

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 (m *Input) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Input.Merge(m, 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_77a6da22d6a3feb1, []int{2}
}

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 (m *Output) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Output.Merge(m, 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_77a6da22d6a3feb1, []int{3}
}

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 (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, 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_77a6da22d6a3feb1, []int{4}
}

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 (m *SingleBytes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleBytes.Merge(m, 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 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_77a6da22d6a3feb1, []int{5}
}

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 (m *AccountAndRoot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountAndRoot.Merge(m, 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"`
	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_77a6da22d6a3feb1, []int{6}
}

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 (m *Peer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Peer.Merge(m, 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
}

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_77a6da22d6a3feb1, []int{7}
}

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 (m *PeerList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PeerList.Merge(m, 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_77a6da22d6a3feb1, []int{8}
}

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 (m *ListParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListParams.Merge(m, 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 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_77a6da22d6a3feb1, []int{9}
}

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 (m *BlockHeaderList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeaderList.Merge(m, 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 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_77a6da22d6a3feb1, []int{10}
}

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 (m *CommitResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitResult.Merge(m, 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_77a6da22d6a3feb1, []int{11}
}

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 (m *CommitResultList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitResultList.Merge(m, 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_77a6da22d6a3feb1, []int{12}
}

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 (m *VerifyResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyResult.Merge(m, 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_77a6da22d6a3feb1, []int{13}
}

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 (m *Personal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Personal.Merge(m, 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_77a6da22d6a3feb1, []int{14}
}

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 (m *ImportFormat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportFormat.Merge(m, 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_77a6da22d6a3feb1, []int{15}
}

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 (m *Staking) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Staking.Merge(m, 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_77a6da22d6a3feb1, []int{16}
}

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 (m *Vote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vote.Merge(m, 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 VoteList struct {
	Votes                []*Vote  `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes,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_77a6da22d6a3feb1, []int{17}
}

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 (m *VoteList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteList.Merge(m, 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
}

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_77a6da22d6a3feb1, []int{18}
}

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 (m *NodeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeReq.Merge(m, 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
}

func init() {
	proto.RegisterEnum("types.CommitStatus", CommitStatus_name, CommitStatus_value)
	proto.RegisterEnum("types.VerifyStatus", VerifyStatus_name, VerifyStatus_value)
	proto.RegisterType((*BlockchainStatus)(nil), "types.BlockchainStatus")
	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((*AccountAndRoot)(nil), "types.AccountAndRoot")
	proto.RegisterType((*Peer)(nil), "types.Peer")
	proto.RegisterType((*PeerList)(nil), "types.PeerList")
	proto.RegisterType((*ListParams)(nil), "types.ListParams")
	proto.RegisterType((*BlockHeaderList)(nil), "types.BlockHeaderList")
	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((*VoteList)(nil), "types.VoteList")
	proto.RegisterType((*NodeReq)(nil), "types.NodeReq")
}

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

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

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

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

// 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 {
	NodeState(ctx context.Context, in *NodeReq, opts ...grpc.CallOption) (*SingleBytes, error)
	Metric(ctx context.Context, in *MetricsRequest, opts ...grpc.CallOption) (*Metrics, error)
	Blockchain(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*BlockchainStatus, error)
	ListBlockHeaders(ctx context.Context, in *ListParams, opts ...grpc.CallOption) (*BlockHeaderList, error)
	ListBlockStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AergoRPCService_ListBlockStreamClient, error)
	GetBlock(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Block, error)
	GetTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Tx, error)
	GetBlockTX(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*TxInBlock, error)
	GetReceipt(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Receipt, error)
	GetABI(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*ABI, error)
	SendTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*CommitResult, error)
	CommitTX(ctx context.Context, in *TxList, opts ...grpc.CallOption) (*CommitResultList, error)
	GetState(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*State, error)
	GetStateAndProof(ctx context.Context, in *AccountAndRoot, opts ...grpc.CallOption) (*StateProof, error)
	CreateAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	GetAccounts(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*AccountList, error)
	LockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	UnlockAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*Account, error)
	ImportAccount(ctx context.Context, in *ImportFormat, opts ...grpc.CallOption) (*Account, error)
	ExportAccount(ctx context.Context, in *Personal, opts ...grpc.CallOption) (*SingleBytes, error)
	SignTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*Tx, error)
	VerifyTX(ctx context.Context, in *Tx, opts ...grpc.CallOption) (*VerifyResult, error)
	QueryContract(ctx context.Context, in *Query, opts ...grpc.CallOption) (*SingleBytes, error)
	QueryContractState(ctx context.Context, in *StateQuery, opts ...grpc.CallOption) (*StateQueryProof, error)
	GetPeers(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PeerList, error)
	GetVotes(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*VoteList, error)
	GetStaking(ctx context.Context, in *SingleBytes, opts ...grpc.CallOption) (*Staking, 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) 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) 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) 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) 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) 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) (*StateProof, error) {
	out := new(StateProof)
	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) 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) 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 *Empty, 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 *SingleBytes, 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) GetStaking(ctx context.Context, in *SingleBytes, 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
}

// AergoRPCServiceServer is the server API for AergoRPCService service.
type AergoRPCServiceServer interface {
	NodeState(context.Context, *NodeReq) (*SingleBytes, error)
	Metric(context.Context, *MetricsRequest) (*Metrics, error)
	Blockchain(context.Context, *Empty) (*BlockchainStatus, error)
	ListBlockHeaders(context.Context, *ListParams) (*BlockHeaderList, error)
	ListBlockStream(*Empty, AergoRPCService_ListBlockStreamServer) error
	GetBlock(context.Context, *SingleBytes) (*Block, error)
	GetTX(context.Context, *SingleBytes) (*Tx, error)
	GetBlockTX(context.Context, *SingleBytes) (*TxInBlock, error)
	GetReceipt(context.Context, *SingleBytes) (*Receipt, error)
	GetABI(context.Context, *SingleBytes) (*ABI, error)
	SendTX(context.Context, *Tx) (*CommitResult, error)
	CommitTX(context.Context, *TxList) (*CommitResultList, error)
	GetState(context.Context, *SingleBytes) (*State, error)
	GetStateAndProof(context.Context, *AccountAndRoot) (*StateProof, error)
	CreateAccount(context.Context, *Personal) (*Account, error)
	GetAccounts(context.Context, *Empty) (*AccountList, error)
	LockAccount(context.Context, *Personal) (*Account, error)
	UnlockAccount(context.Context, *Personal) (*Account, error)
	ImportAccount(context.Context, *ImportFormat) (*Account, error)
	ExportAccount(context.Context, *Personal) (*SingleBytes, error)
	SignTX(context.Context, *Tx) (*Tx, error)
	VerifyTX(context.Context, *Tx) (*VerifyResult, error)
	QueryContract(context.Context, *Query) (*SingleBytes, error)
	QueryContractState(context.Context, *StateQuery) (*StateQueryProof, error)
	GetPeers(context.Context, *Empty) (*PeerList, error)
	GetVotes(context.Context, *SingleBytes) (*VoteList, error)
	GetStaking(context.Context, *SingleBytes) (*Staking, 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_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_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_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_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_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_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_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(Empty)
	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.(*Empty))
	}
	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(SingleBytes)
	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.(*SingleBytes))
	}
	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(SingleBytes)
	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.(*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: "ListBlockHeaders",
			Handler:    _AergoRPCService_ListBlockHeaders_Handler,
		},
		{
			MethodName: "GetBlock",
			Handler:    _AergoRPCService_GetBlock_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: "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: "SignTX",
			Handler:    _AergoRPCService_SignTX_Handler,
		},
		{
			MethodName: "VerifyTX",
			Handler:    _AergoRPCService_VerifyTX_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: "GetStaking",
			Handler:    _AergoRPCService_GetStaking_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListBlockStream",
			Handler:       _AergoRPCService_ListBlockStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpc.proto",
}