api

type APIServiceClient interface {
	// GetTries gets all tries. Admin privilege is required
	GetTries(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (APIService_GetTriesClient, error)
	// GetTrie gets a trie
	GetTrie(ctx context.Context, in *TrieRequest, opts ...grpc.CallOption) (*Trie, error)
	// ImportTrie creates a new trie from existing trie data. If the trie ID is
	// not provided in the metadata, a new one will be generated
	ImportTrie(ctx context.Context, opts ...grpc.CallOption) (APIService_ImportTrieClient, error)
	// ExportTrie exports a trie's data
	ExportTrie(ctx context.Context, in *TrieRequest, opts ...grpc.CallOption) (APIService_ExportTrieClient, error)
	// CreateTrie creates an empty trie
	CreateTrie(ctx context.Context, in *CreateTrieRequest, opts ...grpc.CallOption) (*Trie, error)
	// DeleteTrie deletes a trie. This destroys everything of a trie
	DeleteTrie(ctx context.Context, in *TrieRequest, opts ...grpc.CallOption) (*Trie, error)
	// GetTrieKeyValues gets key-values of a trie. The returned KeyValues are
	// ordered by the keys lexicographically
	GetTrieKeyValues(ctx context.Context, in *TrieKeyValuesRequest, opts ...grpc.CallOption) (APIService_GetTrieKeyValuesClient, error)
	// GetTrieKeyValue gets a key-value of a trie
	GetTrieKeyValue(ctx context.Context, in *TrieKeyValueRequest, opts ...grpc.CallOption) (*KeyValue, error)
	// SetTrieKeyValues sets key-values of a trie. Set an empty value for a key to
	// remove that key. Modifications to a trie will change its root hash
	SetTrieKeyValues(ctx context.Context, opts ...grpc.CallOption) (APIService_SetTrieKeyValuesClient, error)
	// GetTrieRoots gets roots of a trie. This is a series of roots showing the
	// modification history of a trie
	GetTrieRoots(ctx context.Context, in *TrieRootsRequest, opts ...grpc.CallOption) (APIService_GetTrieRootsClient, error)
	// SetTrieRoot sets the root of a trie to the given one. This will add an
	// entry in the root history
	SetTrieRoot(ctx context.Context, in *SetTrieRootRequest, opts ...grpc.CallOption) (*Trie, error)
	// SetTrieStorageType sets the storage type of a trie
	SetTrieStorageType(ctx context.Context, in *SetTrieStorageTypeRequest, opts ...grpc.CallOption) (*Trie, error)
	// GetTrieProofs gets proofs of a trie
	GetTrieProofs(ctx context.Context, in *TrieProofsRequest, opts ...grpc.CallOption) (APIService_GetTrieProofsClient, error)
	// GetTrieProof gets a proof of a trie. When not_before is not provided
	// (either nil or zero), the latest proof will be returned
	GetTrieProof(ctx context.Context, in *TrieProofRequest, opts ...grpc.CallOption) (*TrieProof, error)
	// SubscribeTrieProof subscribes to proof changes of a trie. When not_before
	// is not provided (either nil or zero), the latest proof will be returned
	SubscribeTrieProof(ctx context.Context, in *TrieProofRequest, opts ...grpc.CallOption) (APIService_SubscribeTrieProofClient, error)
	// CreateTrieProof creates a proof for a trie root
	CreateTrieProof(ctx context.Context, in *CreateTrieProofRequest, opts ...grpc.CallOption) (*TrieProof, error)
	// DeleteTrieProof deletes a proof for a trie root
	DeleteTrieProof(ctx context.Context, in *DeleteTrieProofRequest, opts ...grpc.CallOption) (*TrieProof, error)
	// VerifyTrieProof verifies a proof for a trie root
	VerifyTrieProof(ctx context.Context, in *VerifyTrieProofRequest, opts ...grpc.CallOption) (APIService_VerifyTrieProofClient, error)
	// CreateKeyValuesProof creates a proof for the provided key-values out of a
	// trie proof. The new proof is self-contained and can be verified
	// independently
	CreateKeyValuesProof(ctx context.Context, in *CreateKeyValuesProofRequest, opts ...grpc.CallOption) (APIService_CreateKeyValuesProofClient, error)
	// VerifyKeyValuesProof verifies a key-values proof
	VerifyKeyValuesProof(ctx context.Context, opts ...grpc.CallOption) (APIService_VerifyKeyValuesProofClient, error)
}

type APIServiceServer interface {
	// GetTries gets all tries. Admin privilege is required
	GetTries(*empty.Empty, APIService_GetTriesServer) error
	// GetTrie gets a trie
	GetTrie(context.Context, *TrieRequest) (*Trie, error)
	// ImportTrie creates a new trie from existing trie data. If the trie ID is
	// not provided in the metadata, a new one will be generated
	ImportTrie(APIService_ImportTrieServer) error
	// ExportTrie exports a trie's data
	ExportTrie(*TrieRequest, APIService_ExportTrieServer) error
	// CreateTrie creates an empty trie
	CreateTrie(context.Context, *CreateTrieRequest) (*Trie, error)
	// DeleteTrie deletes a trie. This destroys everything of a trie
	DeleteTrie(context.Context, *TrieRequest) (*Trie, error)
	// GetTrieKeyValues gets key-values of a trie. The returned KeyValues are
	// ordered by the keys lexicographically
	GetTrieKeyValues(*TrieKeyValuesRequest, APIService_GetTrieKeyValuesServer) error
	// GetTrieKeyValue gets a key-value of a trie
	GetTrieKeyValue(context.Context, *TrieKeyValueRequest) (*KeyValue, error)
	// SetTrieKeyValues sets key-values of a trie. Set an empty value for a key to
	// remove that key. Modifications to a trie will change its root hash
	SetTrieKeyValues(APIService_SetTrieKeyValuesServer) error
	// GetTrieRoots gets roots of a trie. This is a series of roots showing the
	// modification history of a trie
	GetTrieRoots(*TrieRootsRequest, APIService_GetTrieRootsServer) error
	// SetTrieRoot sets the root of a trie to the given one. This will add an
	// entry in the root history
	SetTrieRoot(context.Context, *SetTrieRootRequest) (*Trie, error)
	// SetTrieStorageType sets the storage type of a trie
	SetTrieStorageType(context.Context, *SetTrieStorageTypeRequest) (*Trie, error)
	// GetTrieProofs gets proofs of a trie
	GetTrieProofs(*TrieProofsRequest, APIService_GetTrieProofsServer) error
	// GetTrieProof gets a proof of a trie. When not_before is not provided
	// (either nil or zero), the latest proof will be returned
	GetTrieProof(context.Context, *TrieProofRequest) (*TrieProof, error)
	// SubscribeTrieProof subscribes to proof changes of a trie. When not_before
	// is not provided (either nil or zero), the latest proof will be returned
	SubscribeTrieProof(*TrieProofRequest, APIService_SubscribeTrieProofServer) error
	// CreateTrieProof creates a proof for a trie root
	CreateTrieProof(context.Context, *CreateTrieProofRequest) (*TrieProof, error)
	// DeleteTrieProof deletes a proof for a trie root
	DeleteTrieProof(context.Context, *DeleteTrieProofRequest) (*TrieProof, error)
	// VerifyTrieProof verifies a proof for a trie root
	VerifyTrieProof(*VerifyTrieProofRequest, APIService_VerifyTrieProofServer) error
	// CreateKeyValuesProof creates a proof for the provided key-values out of a
	// trie proof. The new proof is self-contained and can be verified
	// independently
	CreateKeyValuesProof(*CreateKeyValuesProofRequest, APIService_CreateKeyValuesProofServer) error
	// VerifyKeyValuesProof verifies a key-values proof
	VerifyKeyValuesProof(APIService_VerifyKeyValuesProofServer) error
}

type APIService_CreateKeyValuesProofClient interface {
	Recv() (*DataChunk, error)
	grpc.ClientStream
}

type APIService_CreateKeyValuesProofServer interface {
	Send(*DataChunk) error
	grpc.ServerStream
}

type APIService_ExportTrieClient interface {
	Recv() (*DataChunk, error)
	grpc.ClientStream
}

type APIService_ExportTrieServer interface {
	Send(*DataChunk) error
	grpc.ServerStream
}

type APIService_GetTrieKeyValuesClient interface {
	Recv() (*KeyValue, error)
	grpc.ClientStream
}

type APIService_GetTrieKeyValuesServer interface {
	Send(*KeyValue) error
	grpc.ServerStream
}

type APIService_GetTrieProofsClient interface {
	Recv() (*TrieProof, error)
	grpc.ClientStream
}

type APIService_GetTrieProofsServer interface {
	Send(*TrieProof) error
	grpc.ServerStream
}

type APIService_GetTrieRootsClient interface {
	Recv() (*TrieRoot, error)
	grpc.ClientStream
}

type APIService_GetTrieRootsServer interface {
	Send(*TrieRoot) error
	grpc.ServerStream
}

type APIService_GetTriesClient interface {
	Recv() (*Trie, error)
	grpc.ClientStream
}

type APIService_GetTriesServer interface {
	Send(*Trie) error
	grpc.ServerStream
}

type APIService_ImportTrieClient interface {
	Send(*DataChunk) error
	CloseAndRecv() (*Trie, error)
	grpc.ClientStream
}

type APIService_ImportTrieServer interface {
	SendAndClose(*Trie) error
	Recv() (*DataChunk, error)
	grpc.ServerStream
}

type APIService_SetTrieKeyValuesClient interface {
	Send(*KeyValue) error
	CloseAndRecv() (*Trie, error)
	grpc.ClientStream
}

type APIService_SetTrieKeyValuesServer interface {
	SendAndClose(*Trie) error
	Recv() (*KeyValue, error)
	grpc.ServerStream
}

type APIService_SubscribeTrieProofClient interface {
	Recv() (*TrieProof, error)
	grpc.ClientStream
}

type APIService_SubscribeTrieProofServer interface {
	Send(*TrieProof) error
	grpc.ServerStream
}

type APIService_VerifyKeyValuesProofClient interface {
	Send(*DataChunk) error
	Recv() (*VerifyProofReplyChunk, error)
	grpc.ClientStream
}

type APIService_VerifyKeyValuesProofServer interface {
	Send(*VerifyProofReplyChunk) error
	Recv() (*DataChunk, error)
	grpc.ServerStream
}

type APIService_VerifyTrieProofClient interface {
	Recv() (*VerifyProofReplyChunk, error)
	grpc.ClientStream
}

type APIService_VerifyTrieProofServer interface {
	Send(*VerifyProofReplyChunk) error
	grpc.ServerStream
}

type CreateKeyValuesProofRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// TrieProof is the trie proof to use. When TrieProof is zero, a new trie
	// proof will be created with current root and ETH
	//
	// Types that are valid to be assigned to TrieProof:
	//	*CreateKeyValuesProofRequest_ProofId
	//	*CreateKeyValuesProofRequest_Request
	TrieProof isCreateKeyValuesProofRequest_TrieProof `protobuf_oneof:"trie_proof"`
	// Filter is the key-values filter (optional). When zero, all key-values will
	// be included in the proof
	Filter               *KeyValuesFilter `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type CreateKeyValuesProofRequest_ProofId struct {
	ProofId string `protobuf:"bytes,2,opt,name=proof_id,json=proofId,proto3,oneof"`
}

type CreateKeyValuesProofRequest_Request struct {
	Request *CreateTrieProofRequest `protobuf:"bytes,3,opt,name=request,proto3,oneof"`
}

type CreateTrieProofRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Root is the root hash (optional). When zero, the current root hash of the
	// trie will be used to create the TrieProof, and the request will be blocked
	// until all ongoing updates are finished
	Root string `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	// AnchorType is the anchor type the trie proof should be submitted to.
	// Default to ETH
	AnchorType           anchor.Anchor_Type `protobuf:"varint,3,opt,name=anchor_type,json=anchorType,proto3,enum=anchor.Anchor_Type" json:"anchor_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

type CreateTrieRequest struct {
	// StorageType is the storage type of the trie to be created
	StorageType          Trie_StorageType `protobuf:"varint,1,opt,name=storage_type,json=storageType,proto3,enum=api.Trie_StorageType" json:"storage_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type DataChunk struct {
	// Data is the data within the DataChunk
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// Metadata is the metadata of the DataChunk stream, which is available in the
	// first DataChunk
	//
	// Types that are valid to be assigned to Metadata:
	//	*DataChunk_ImportTrieRequest
	//	*DataChunk_VerifyKeyValuesProofRequest
	Metadata             isDataChunk_Metadata `protobuf_oneof:"metadata"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

type DataChunkMetadata = isDataChunk_Metadata

type DataChunk_ImportTrieRequest struct {
	ImportTrieRequest *ImportTrieRequest `protobuf:"bytes,2,opt,name=import_trie_request,json=importTrieRequest,proto3,oneof"`
}

type DataChunk_VerifyKeyValuesProofRequest struct {
	VerifyKeyValuesProofRequest *VerifyKeyValuesProofRequest `protobuf:"bytes,3,opt,name=verify_key_values_proof_request,json=verifyKeyValuesProofRequest,proto3,oneof"`
}

type DataStreamReciever interface {
	Context() context.Context
	Recv() (*DataChunk, error)
}

type DataStreamSender interface {
	Context() context.Context
	Send(*DataChunk) error
}

type DeleteTrieProofRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// ProofId is the trie proof ID
	ProofId              string   `protobuf:"bytes,2,opt,name=proof_id,json=proofId,proto3" json:"proof_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ImportTrieRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// StorageType is the storage type of the trie
	StorageType          Trie_StorageType `protobuf:"varint,2,opt,name=storage_type,json=storageType,proto3,enum=api.Trie_StorageType" json:"storage_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type Key struct {
	// Key is the key of the key-value
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// KeySep is the key separators for chained tries
	KeySep               []uint32 `protobuf:"varint,2,rep,packed,name=key_sep,json=keySep,proto3" json:"key_sep,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type KeyValue struct {
	// Key is the key of the key-value
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// KeySep is the key separators for chained tries
	KeySep []uint32 `protobuf:"varint,2,rep,packed,name=key_sep,json=keySep,proto3" json:"key_sep,omitempty"`
	// Value is the value of the key-value
	Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	// Metadata is the metadata of the KeyValue stream, which is available in the
	// first KeyValue
	//
	// Types that are valid to be assigned to Metadata:
	//	*KeyValue_TrieKeyValuesRequest
	Metadata             isKeyValue_Metadata `protobuf_oneof:"metadata"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

type KeyValue_TrieKeyValuesRequest struct {
	TrieKeyValuesRequest *TrieKeyValuesRequest `protobuf:"bytes,4,opt,name=trie_key_values_request,json=trieKeyValuesRequest,proto3,oneof"`
}

type KeyValuesFilter struct {
	// Keys are the keys of key-values that should be included in a key-value
	// proof. Only those trie nodes are on the merkle paths of the given keys will
	// be included in the proof
	Keys                 []*Key   `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type RootFilter struct {
	// Root is the root hash. When zero, the current root hash of the trie will be
	// used to retrieve the TrieProof, and the request will be blocked until all
	// ongoing updates are finished
	Root string `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	// NotBefore is the not before timestamp. When nil, this constraint is not
	// used; when zero, the latest TrieProof for the root hash will be returned
	NotBefore            *timestamp.Timestamp `protobuf:"bytes,2,opt,name=not_before,json=notBefore,proto3" json:"not_before,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

type SetTrieRootRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Root is the root hash to set to
	Root                 string   `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type SetTrieStorageTypeRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// StorageType is the storage type of the trie to be updated to
	StorageType          Trie_StorageType `protobuf:"varint,2,opt,name=storage_type,json=storageType,proto3,enum=api.Trie_StorageType" json:"storage_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type Trie struct {
	// Id is the trie ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Root is the root hash of the trie
	Root string `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	// StorageType is the storage type of the trie
	StorageType          Trie_StorageType `protobuf:"varint,3,opt,name=storage_type,json=storageType,proto3,enum=api.Trie_StorageType" json:"storage_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type TrieKeyValueRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Root is the root hash (optional). When zero, the current root hash of the
	// trie will be used to retrieve the TrieKeyValues, and the request will be
	// blocked until all ongoing updates are finished
	Root string `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	// Key is the key of the key-value
	Key                  *Key     `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TrieKeyValuesRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Root is the root hash (optional). When zero, the current root hash of the
	// trie will be used to retrieve the TrieKeyValues, and the request will be
	// blocked until all ongoing updates are finished
	Root                 string   `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TrieProof struct {
	// Id is the ID of the trie proof
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,2,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Root is the root hash of the trie proven by this proof
	Root string `protobuf:"bytes,3,opt,name=root,proto3" json:"root,omitempty"`
	// CreatedAt is the created at timestamp. The timestamp when the proof is
	// created
	CreatedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Status is the anchor batch status of the trie proof
	Status anchor.Batch_Status `protobuf:"varint,5,opt,name=status,proto3,enum=anchor.Batch_Status" json:"status,omitempty"`
	// Error is the error message when status is ERROR
	Error string `protobuf:"bytes,6,opt,name=error,proto3" json:"error,omitempty"`
	// AnchorType is the anchor type the trie proof has been submitted to
	AnchorType anchor.Anchor_Type `protobuf:"varint,7,opt,name=anchor_type,json=anchorType,proto3,enum=anchor.Anchor_Type" json:"anchor_type,omitempty"`
	// TxnId is the blockchain transaction ID
	TxnId string `protobuf:"bytes,8,opt,name=txn_id,json=txnId,proto3" json:"txn_id,omitempty"`
	// TxnUri is the explorer URI for the blockchain transaction
	TxnUri string `protobuf:"bytes,12,opt,name=txn_uri,json=txnUri,proto3" json:"txn_uri,omitempty"`
	// BlockTime is the blockchain's block consensus timestamp in seconds
	BlockTime uint64 `protobuf:"varint,9,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"`
	// BlockTimeNano is the Blockcahin's block consensus timestamp's nano part.
	// For most traditional blockchains, this will be zero. For Hedera, this will
	// be the nano part of the transaction's consensus timestamp
	BlockTimeNano uint64 `protobuf:"varint,13,opt,name=block_time_nano,json=blockTimeNano,proto3" json:"block_time_nano,omitempty"`
	// BlockNumber is the blockchain's block number. For Hedera, this will be zero
	// as there is no block concept and each transaction has its own consensus
	// timestamp which defines the transaction order
	BlockNumber uint64 `protobuf:"varint,10,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	// ProofRoot is the root hash of the trie proof, which is the anchor batch's
	// root hash the proof belongs to
	ProofRoot            string   `protobuf:"bytes,11,opt,name=proof_root,json=proofRoot,proto3" json:"proof_root,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TrieProofRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// Query is the query to get the TrieProof
	//
	// Types that are valid to be assigned to Query:
	//	*TrieProofRequest_ProofId
	//	*TrieProofRequest_RootFilter
	Query                isTrieProofRequest_Query `protobuf_oneof:"query"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

type TrieProofRequest_ProofId struct {
	ProofId string `protobuf:"bytes,2,opt,name=proof_id,json=proofId,proto3,oneof"`
}

type TrieProofRequest_RootFilter struct {
	RootFilter *RootFilter `protobuf:"bytes,3,opt,name=root_filter,json=rootFilter,proto3,oneof"`
}

type TrieProofsRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// RootFilter is the root filter (optional). When nil, all TrieProofs will be
	// returned
	RootFilter           *RootFilter `protobuf:"bytes,2,opt,name=root_filter,json=rootFilter,proto3" json:"root_filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type TrieRequest struct {
	// TrieId is the trie ID
	TrieId               string   `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TrieRoot struct {
	// Root is the root hash of the trie
	Root string `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	// CreatedAt is the created at timestamp. The timestamp when the root is
	// created
	CreatedAt            *timestamp.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

type TrieRootsRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// RootFilter is the root filter (optional). When nil, all TrieRoots will be
	// returned
	RootFilter           *RootFilter `protobuf:"bytes,2,opt,name=root_filter,json=rootFilter,proto3" json:"root_filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type Trie_StorageType int32

type VerifyKeyValuesProofRequest struct {
	// OutputKeyValues indicates whether to output key-values contained in the
	// trie
	OutputKeyValues bool `protobuf:"varint,1,opt,name=output_key_values,json=outputKeyValues,proto3" json:"output_key_values,omitempty"`
	// OutputDotGraph indicates whether to output a Graphviz dot graph to
	// visualize the trie
	OutputDotGraph       bool     `protobuf:"varint,2,opt,name=output_dot_graph,json=outputDotGraph,proto3" json:"output_dot_graph,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type VerifyProofReply struct {
	// Verified indicates whether the proof is verified
	Verified bool `protobuf:"varint,1,opt,name=verified,proto3" json:"verified,omitempty"`
	// Error is the error message when the proof is falsified
	Error                string   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type VerifyProofReplyChunk struct {
	// Data is the data contained in the chunk
	//
	// Types that are valid to be assigned to Data:
	//	*VerifyProofReplyChunk_KeyValue
	//	*VerifyProofReplyChunk_DotGraphChunk
	//	*VerifyProofReplyChunk_Reply
	Data                 isVerifyProofReplyChunk_Data `protobuf_oneof:"data"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

type VerifyProofReplyChunk_DotGraphChunk struct {
	DotGraphChunk *DataChunk `protobuf:"bytes,2,opt,name=dot_graph_chunk,json=dotGraphChunk,proto3,oneof"`
}

type VerifyProofReplyChunk_KeyValue struct {
	KeyValue *KeyValue `protobuf:"bytes,1,opt,name=key_value,json=keyValue,proto3,oneof"`
}

type VerifyProofReplyChunk_Reply struct {
	Reply *VerifyProofReply `protobuf:"bytes,3,opt,name=reply,proto3,oneof"`
}

type VerifyProofReplyStreamReader struct {

	// DotGraph is dot graph reader. It must be closed to ensure all data are read
	DotGraph io.ReadCloser
	// contains filtered or unexported fields
}

type VerifyProofReplyStreamReciever interface {
	Context() context.Context
	Recv() (*VerifyProofReplyChunk, error)
}

type VerifyProofReplyStreamSender interface {
	Context() context.Context
	Send(*VerifyProofReplyChunk) error
}

type VerifyProofReplyStreamWriter struct {

	// DotGraph is dot graph writer. It must be closed to ensure all data are written
	DotGraph io.WriteCloser
	// contains filtered or unexported fields
}

type VerifyTrieProofRequest struct {
	// TrieId is the trie ID
	TrieId string `protobuf:"bytes,1,opt,name=trie_id,json=trieId,proto3" json:"trie_id,omitempty"`
	// ProofId is the trie proof ID
	ProofId string `protobuf:"bytes,2,opt,name=proof_id,json=proofId,proto3" json:"proof_id,omitempty"`
	// OutputKeyValues indicates whether to output key-values contained in the
	// trie
	OutputKeyValues bool `protobuf:"varint,3,opt,name=output_key_values,json=outputKeyValues,proto3" json:"output_key_values,omitempty"`
	// OutputDotGraph indicates whether to output a Graphviz dot graph to
	// visualize the trie
	OutputDotGraph       bool     `protobuf:"varint,4,opt,name=output_dot_graph,json=outputDotGraph,proto3" json:"output_dot_graph,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}