// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.32.1
// source: services/blockassembly/blockassembly_api/blockassembly_api.proto

package blockassembly_api

import (
	model "github.com/bsv-blockchain/teranode/model"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// An empty message used as a placeholder or a request with no data.
type EmptyMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EmptyMessage) Reset() {
	*x = EmptyMessage{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EmptyMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EmptyMessage) ProtoMessage() {}

func (x *EmptyMessage) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EmptyMessage.ProtoReflect.Descriptor instead.
func (*EmptyMessage) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{0}
}

// Contains the health status of the service. Includes an 'ok' flag indicating health status, details providing more context, and a timestamp.
type HealthResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ok            bool                   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`              // true if the service is healthy
	Details       string                 `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`     // optional, human-readable details
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // unix timestamp
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HealthResponse) Reset() {
	*x = HealthResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *HealthResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HealthResponse) ProtoMessage() {}

func (x *HealthResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HealthResponse.ProtoReflect.Descriptor instead.
func (*HealthResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{1}
}

func (x *HealthResponse) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

func (x *HealthResponse) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

func (x *HealthResponse) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

// Request for adding a new chaintip and height information.
type NewChaintipAndHeightRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Chaintip      []byte                 `protobuf:"bytes,1,opt,name=chaintip,proto3" json:"chaintip,omitempty"` // the chaintip hash
	Height        uint32                 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`    // the height of the chaintip in the blockchain
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NewChaintipAndHeightRequest) Reset() {
	*x = NewChaintipAndHeightRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NewChaintipAndHeightRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NewChaintipAndHeightRequest) ProtoMessage() {}

func (x *NewChaintipAndHeightRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NewChaintipAndHeightRequest.ProtoReflect.Descriptor instead.
func (*NewChaintipAndHeightRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{2}
}

func (x *NewChaintipAndHeightRequest) GetChaintip() []byte {
	if x != nil {
		return x.Chaintip
	}
	return nil
}

func (x *NewChaintipAndHeightRequest) GetHeight() uint32 {
	if x != nil {
		return x.Height
	}
	return 0
}

// Request for adding a new transaction to the mining candidate block.
type AddTxRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Txid          []byte                 `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`             // the transaction id
	Fee           uint64                 `protobuf:"varint,3,opt,name=fee,proto3" json:"fee,omitempty"`              // the transaction fee in satoshis
	Size          uint64                 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`            // the size of the transaction in bytes
	Locktime      uint32                 `protobuf:"varint,2,opt,name=locktime,proto3" json:"locktime,omitempty"`    // the earliest time a transaction can be mined into a block
	Utxos         [][]byte               `protobuf:"bytes,5,rep,name=utxos,proto3" json:"utxos,omitempty"`           // the UTXOs consumed by this transaction
	TxInpoints    []byte                 `protobuf:"bytes,6,opt,name=txInpoints,proto3" json:"txInpoints,omitempty"` // a serialized list of input outpoints for this transaction
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddTxRequest) Reset() {
	*x = AddTxRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddTxRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddTxRequest) ProtoMessage() {}

func (x *AddTxRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddTxRequest.ProtoReflect.Descriptor instead.
func (*AddTxRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{3}
}

func (x *AddTxRequest) GetTxid() []byte {
	if x != nil {
		return x.Txid
	}
	return nil
}

func (x *AddTxRequest) GetFee() uint64 {
	if x != nil {
		return x.Fee
	}
	return 0
}

func (x *AddTxRequest) GetSize() uint64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *AddTxRequest) GetLocktime() uint32 {
	if x != nil {
		return x.Locktime
	}
	return 0
}

func (x *AddTxRequest) GetUtxos() [][]byte {
	if x != nil {
		return x.Utxos
	}
	return nil
}

func (x *AddTxRequest) GetTxInpoints() []byte {
	if x != nil {
		return x.TxInpoints
	}
	return nil
}

// Request for adding a batch of transactions to the mining candidate block.
type AddTxBatchRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TxRequests    []*AddTxRequest        `protobuf:"bytes,1,rep,name=txRequests,proto3" json:"txRequests,omitempty"` // a batch of transaction requests
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddTxBatchRequest) Reset() {
	*x = AddTxBatchRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddTxBatchRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddTxBatchRequest) ProtoMessage() {}

func (x *AddTxBatchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddTxBatchRequest.ProtoReflect.Descriptor instead.
func (*AddTxBatchRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{4}
}

func (x *AddTxBatchRequest) GetTxRequests() []*AddTxRequest {
	if x != nil {
		return x.TxRequests
	}
	return nil
}

// Request for retrieving a mining candidate block template.
type GetMiningCandidateRequest struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	IncludeSubtrees bool                   `protobuf:"varint,1,opt,name=includeSubtrees,proto3" json:"includeSubtrees,omitempty"` // whether to include the subtrees in the mining candidate
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *GetMiningCandidateRequest) Reset() {
	*x = GetMiningCandidateRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetMiningCandidateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetMiningCandidateRequest) ProtoMessage() {}

func (x *GetMiningCandidateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetMiningCandidateRequest.ProtoReflect.Descriptor instead.
func (*GetMiningCandidateRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{5}
}

func (x *GetMiningCandidateRequest) GetIncludeSubtrees() bool {
	if x != nil {
		return x.IncludeSubtrees
	}
	return false
}

// Request for removing a transaction from the mining candidate block.
type RemoveTxRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Txid          []byte                 `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` // the transaction id to remove
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RemoveTxRequest) Reset() {
	*x = RemoveTxRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RemoveTxRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RemoveTxRequest) ProtoMessage() {}

func (x *RemoveTxRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RemoveTxRequest.ProtoReflect.Descriptor instead.
func (*RemoveTxRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{6}
}

func (x *RemoveTxRequest) GetTxid() []byte {
	if x != nil {
		return x.Txid
	}
	return nil
}

// Response indicating whether the addition of a transaction was successful.
type AddTxResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ok            bool                   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` // true if the transaction was successfully added
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddTxResponse) Reset() {
	*x = AddTxResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddTxResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddTxResponse) ProtoMessage() {}

func (x *AddTxResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddTxResponse.ProtoReflect.Descriptor instead.
func (*AddTxResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{7}
}

func (x *AddTxResponse) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

// Response indicating whether the addition of a batch of transactions was successful.
type AddTxBatchResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ok            bool                   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` // true if the transactions were successfully added
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddTxBatchResponse) Reset() {
	*x = AddTxBatchResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddTxBatchResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddTxBatchResponse) ProtoMessage() {}

func (x *AddTxBatchResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddTxBatchResponse.ProtoReflect.Descriptor instead.
func (*AddTxBatchResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{8}
}

func (x *AddTxBatchResponse) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

// Request for submitting a mining solution to the blockchain.
type SubmitMiningSolutionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            []byte                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`                                   // the id of the mining candidate
	Nonce         uint32                 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`                            // the nonce value used for mining
	CoinbaseTx    []byte                 `protobuf:"bytes,3,opt,name=coinbase_tx,json=coinbaseTx,proto3" json:"coinbase_tx,omitempty"` // the coinbase transaction bytes
	Time          *uint32                `protobuf:"varint,4,opt,name=time,proto3,oneof" json:"time,omitempty"`                        // the timestamp of the block
	Version       *uint32                `protobuf:"varint,5,opt,name=version,proto3,oneof" json:"version,omitempty"`                  // the version of the block
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubmitMiningSolutionRequest) Reset() {
	*x = SubmitMiningSolutionRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SubmitMiningSolutionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SubmitMiningSolutionRequest) ProtoMessage() {}

func (x *SubmitMiningSolutionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SubmitMiningSolutionRequest.ProtoReflect.Descriptor instead.
func (*SubmitMiningSolutionRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{9}
}

func (x *SubmitMiningSolutionRequest) GetId() []byte {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *SubmitMiningSolutionRequest) GetNonce() uint32 {
	if x != nil {
		return x.Nonce
	}
	return 0
}

func (x *SubmitMiningSolutionRequest) GetCoinbaseTx() []byte {
	if x != nil {
		return x.CoinbaseTx
	}
	return nil
}

func (x *SubmitMiningSolutionRequest) GetTime() uint32 {
	if x != nil && x.Time != nil {
		return *x.Time
	}
	return 0
}

func (x *SubmitMiningSolutionRequest) GetVersion() uint32 {
	if x != nil && x.Version != nil {
		return *x.Version
	}
	return 0
}

// Response indicating whether the call was successful.
type OKResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ok            bool                   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` // true if the call was successful
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OKResponse) Reset() {
	*x = OKResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *OKResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*OKResponse) ProtoMessage() {}

func (x *OKResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use OKResponse.ProtoReflect.Descriptor instead.
func (*OKResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{10}
}

func (x *OKResponse) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

// Message containing the state of the block assembly service.
type StateMessage struct {
	state                 protoimpl.MessageState `protogen:"open.v1"`
	BlockAssemblyState    string                 `protobuf:"bytes,1,opt,name=blockAssemblyState,proto3" json:"blockAssemblyState,omitempty"`       // the state of the block assembly service
	SubtreeProcessorState string                 `protobuf:"bytes,2,opt,name=subtreeProcessorState,proto3" json:"subtreeProcessorState,omitempty"` // the state of the block assembly subtree processor
	SubtreeCount          uint32                 `protobuf:"varint,3,opt,name=subtreeCount,proto3" json:"subtreeCount,omitempty"`                  // the number of subtrees
	TxCount               uint64                 `protobuf:"varint,4,opt,name=txCount,proto3" json:"txCount,omitempty"`                            // the number of transactions
	QueueCount            int64                  `protobuf:"varint,5,opt,name=queueCount,proto3" json:"queueCount,omitempty"`                      // the size of the queue
	CurrentHeight         uint32                 `protobuf:"varint,6,opt,name=currentHeight,proto3" json:"currentHeight,omitempty"`                // the height of the chaintip
	CurrentHash           string                 `protobuf:"bytes,7,opt,name=currentHash,proto3" json:"currentHash,omitempty"`                     // the hash of the chaintip
	RemoveMapCount        uint32                 `protobuf:"varint,8,opt,name=removeMapCount,proto3" json:"removeMapCount,omitempty"`              // the number of transactions in the remove map
	Subtrees              []string               `protobuf:"bytes,9,rep,name=subtrees,proto3" json:"subtrees,omitempty"`                           // the hashes of the current subtrees
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *StateMessage) Reset() {
	*x = StateMessage{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StateMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StateMessage) ProtoMessage() {}

func (x *StateMessage) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StateMessage.ProtoReflect.Descriptor instead.
func (*StateMessage) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{11}
}

func (x *StateMessage) GetBlockAssemblyState() string {
	if x != nil {
		return x.BlockAssemblyState
	}
	return ""
}

func (x *StateMessage) GetSubtreeProcessorState() string {
	if x != nil {
		return x.SubtreeProcessorState
	}
	return ""
}

func (x *StateMessage) GetSubtreeCount() uint32 {
	if x != nil {
		return x.SubtreeCount
	}
	return 0
}

func (x *StateMessage) GetTxCount() uint64 {
	if x != nil {
		return x.TxCount
	}
	return 0
}

func (x *StateMessage) GetQueueCount() int64 {
	if x != nil {
		return x.QueueCount
	}
	return 0
}

func (x *StateMessage) GetCurrentHeight() uint32 {
	if x != nil {
		return x.CurrentHeight
	}
	return 0
}

func (x *StateMessage) GetCurrentHash() string {
	if x != nil {
		return x.CurrentHash
	}
	return ""
}

func (x *StateMessage) GetRemoveMapCount() uint32 {
	if x != nil {
		return x.RemoveMapCount
	}
	return 0
}

func (x *StateMessage) GetSubtrees() []string {
	if x != nil {
		return x.Subtrees
	}
	return nil
}

// Response containing the current difficulty of the blockchain.
type GetCurrentDifficultyResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Difficulty    float64                `protobuf:"fixed64,1,opt,name=difficulty,proto3" json:"difficulty,omitempty"` // the current difficulty of the blockchain
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetCurrentDifficultyResponse) Reset() {
	*x = GetCurrentDifficultyResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetCurrentDifficultyResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetCurrentDifficultyResponse) ProtoMessage() {}

func (x *GetCurrentDifficultyResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetCurrentDifficultyResponse.ProtoReflect.Descriptor instead.
func (*GetCurrentDifficultyResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{12}
}

func (x *GetCurrentDifficultyResponse) GetDifficulty() float64 {
	if x != nil {
		return x.Difficulty
	}
	return 0
}

// Request for generating a block.
type GenerateBlocksRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Count         int32                  `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`             // the number of blocks to generate
	Address       *string                `protobuf:"bytes,2,opt,name=address,proto3,oneof" json:"address,omitempty"`    // the address to send the generated blocks to
	MaxTries      *int32                 `protobuf:"varint,3,opt,name=maxTries,proto3,oneof" json:"maxTries,omitempty"` // the maximum number of attempts to generate a block
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GenerateBlocksRequest) Reset() {
	*x = GenerateBlocksRequest{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GenerateBlocksRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GenerateBlocksRequest) ProtoMessage() {}

func (x *GenerateBlocksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GenerateBlocksRequest.ProtoReflect.Descriptor instead.
func (*GenerateBlocksRequest) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{13}
}

func (x *GenerateBlocksRequest) GetCount() int32 {
	if x != nil {
		return x.Count
	}
	return 0
}

func (x *GenerateBlocksRequest) GetAddress() string {
	if x != nil && x.Address != nil {
		return *x.Address
	}
	return ""
}

func (x *GenerateBlocksRequest) GetMaxTries() int32 {
	if x != nil && x.MaxTries != nil {
		return *x.MaxTries
	}
	return 0
}

// Response for the GetBlockAssemblyBlockCandidate method.
type GetBlockAssemblyBlockCandidateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Block         []byte                 `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` // the block candidate in block assembly
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetBlockAssemblyBlockCandidateResponse) Reset() {
	*x = GetBlockAssemblyBlockCandidateResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetBlockAssemblyBlockCandidateResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetBlockAssemblyBlockCandidateResponse) ProtoMessage() {}

func (x *GetBlockAssemblyBlockCandidateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetBlockAssemblyBlockCandidateResponse.ProtoReflect.Descriptor instead.
func (*GetBlockAssemblyBlockCandidateResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{14}
}

func (x *GetBlockAssemblyBlockCandidateResponse) GetBlock() []byte {
	if x != nil {
		return x.Block
	}
	return nil
}

// Response for the GetBlockAssemblyTxs method.
type GetBlockAssemblyTxsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TxCount       uint64                 `protobuf:"varint,1,opt,name=txCount,proto3" json:"txCount,omitempty"` // the number of transactions in the block assembly
	Txs           []string               `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`          // the transactions currently being assembled in the block assembly
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetBlockAssemblyTxsResponse) Reset() {
	*x = GetBlockAssemblyTxsResponse{}
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetBlockAssemblyTxsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetBlockAssemblyTxsResponse) ProtoMessage() {}

func (x *GetBlockAssemblyTxsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetBlockAssemblyTxsResponse.ProtoReflect.Descriptor instead.
func (*GetBlockAssemblyTxsResponse) Descriptor() ([]byte, []int) {
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP(), []int{15}
}

func (x *GetBlockAssemblyTxsResponse) GetTxCount() uint64 {
	if x != nil {
		return x.TxCount
	}
	return 0
}

func (x *GetBlockAssemblyTxsResponse) GetTxs() []string {
	if x != nil {
		return x.Txs
	}
	return nil
}

var File_services_blockassembly_blockassembly_api_blockassembly_api_proto protoreflect.FileDescriptor

const file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDesc = "" +
	"\n" +
	"@services/blockassembly/blockassembly_api/blockassembly_api.proto\x12\x11blockassembly_api\x1a\x11model/model.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x0e\n" +
	"\fEmptyMessage\"t\n" +
	"\x0eHealthResponse\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\x12\x18\n" +
	"\adetails\x18\x02 \x01(\tR\adetails\x128\n" +
	"\ttimestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\"Q\n" +
	"\x1bNewChaintipAndHeightRequest\x12\x1a\n" +
	"\bchaintip\x18\x01 \x01(\fR\bchaintip\x12\x16\n" +
	"\x06height\x18\x02 \x01(\rR\x06height\"\x9a\x01\n" +
	"\fAddTxRequest\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\fR\x04txid\x12\x10\n" +
	"\x03fee\x18\x03 \x01(\x04R\x03fee\x12\x12\n" +
	"\x04size\x18\x04 \x01(\x04R\x04size\x12\x1a\n" +
	"\blocktime\x18\x02 \x01(\rR\blocktime\x12\x14\n" +
	"\x05utxos\x18\x05 \x03(\fR\x05utxos\x12\x1e\n" +
	"\n" +
	"txInpoints\x18\x06 \x01(\fR\n" +
	"txInpoints\"T\n" +
	"\x11AddTxBatchRequest\x12?\n" +
	"\n" +
	"txRequests\x18\x01 \x03(\v2\x1f.blockassembly_api.AddTxRequestR\n" +
	"txRequests\"E\n" +
	"\x19GetMiningCandidateRequest\x12(\n" +
	"\x0fincludeSubtrees\x18\x01 \x01(\bR\x0fincludeSubtrees\"%\n" +
	"\x0fRemoveTxRequest\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\fR\x04txid\"\x1f\n" +
	"\rAddTxResponse\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\"$\n" +
	"\x12AddTxBatchResponse\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\"\xb1\x01\n" +
	"\x1bSubmitMiningSolutionRequest\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\fR\x02id\x12\x14\n" +
	"\x05nonce\x18\x02 \x01(\rR\x05nonce\x12\x1f\n" +
	"\vcoinbase_tx\x18\x03 \x01(\fR\n" +
	"coinbaseTx\x12\x17\n" +
	"\x04time\x18\x04 \x01(\rH\x00R\x04time\x88\x01\x01\x12\x1d\n" +
	"\aversion\x18\x05 \x01(\rH\x01R\aversion\x88\x01\x01B\a\n" +
	"\x05_timeB\n" +
	"\n" +
	"\b_version\"\x1c\n" +
	"\n" +
	"OKResponse\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\"\xde\x02\n" +
	"\fStateMessage\x12.\n" +
	"\x12blockAssemblyState\x18\x01 \x01(\tR\x12blockAssemblyState\x124\n" +
	"\x15subtreeProcessorState\x18\x02 \x01(\tR\x15subtreeProcessorState\x12\"\n" +
	"\fsubtreeCount\x18\x03 \x01(\rR\fsubtreeCount\x12\x18\n" +
	"\atxCount\x18\x04 \x01(\x04R\atxCount\x12\x1e\n" +
	"\n" +
	"queueCount\x18\x05 \x01(\x03R\n" +
	"queueCount\x12$\n" +
	"\rcurrentHeight\x18\x06 \x01(\rR\rcurrentHeight\x12 \n" +
	"\vcurrentHash\x18\a \x01(\tR\vcurrentHash\x12&\n" +
	"\x0eremoveMapCount\x18\b \x01(\rR\x0eremoveMapCount\x12\x1a\n" +
	"\bsubtrees\x18\t \x03(\tR\bsubtrees\">\n" +
	"\x1cGetCurrentDifficultyResponse\x12\x1e\n" +
	"\n" +
	"difficulty\x18\x01 \x01(\x01R\n" +
	"difficulty\"\x86\x01\n" +
	"\x15GenerateBlocksRequest\x12\x14\n" +
	"\x05count\x18\x01 \x01(\x05R\x05count\x12\x1d\n" +
	"\aaddress\x18\x02 \x01(\tH\x00R\aaddress\x88\x01\x01\x12\x1f\n" +
	"\bmaxTries\x18\x03 \x01(\x05H\x01R\bmaxTries\x88\x01\x01B\n" +
	"\n" +
	"\b_addressB\v\n" +
	"\t_maxTries\">\n" +
	"&GetBlockAssemblyBlockCandidateResponse\x12\x14\n" +
	"\x05block\x18\x01 \x01(\fR\x05block\"I\n" +
	"\x1bGetBlockAssemblyTxsResponse\x12\x18\n" +
	"\atxCount\x18\x01 \x01(\x04R\atxCount\x12\x10\n" +
	"\x03txs\x18\x02 \x03(\tR\x03txs2\xce\n" +
	"\n" +
	"\x10BlockAssemblyAPI\x12R\n" +
	"\n" +
	"HealthGRPC\x12\x1f.blockassembly_api.EmptyMessage\x1a!.blockassembly_api.HealthResponse\"\x00\x12L\n" +
	"\x05AddTx\x12\x1f.blockassembly_api.AddTxRequest\x1a .blockassembly_api.AddTxResponse\"\x00\x12Q\n" +
	"\bRemoveTx\x12\".blockassembly_api.RemoveTxRequest\x1a\x1f.blockassembly_api.EmptyMessage\"\x00\x12[\n" +
	"\n" +
	"AddTxBatch\x12$.blockassembly_api.AddTxBatchRequest\x1a%.blockassembly_api.AddTxBatchResponse\"\x00\x12\\\n" +
	"\x12GetMiningCandidate\x12,.blockassembly_api.GetMiningCandidateRequest\x1a\x16.model.MiningCandidate\"\x00\x12j\n" +
	"\x14GetCurrentDifficulty\x12\x1f.blockassembly_api.EmptyMessage\x1a/.blockassembly_api.GetCurrentDifficultyResponse\"\x00\x12g\n" +
	"\x14SubmitMiningSolution\x12..blockassembly_api.SubmitMiningSolutionRequest\x1a\x1d.blockassembly_api.OKResponse\"\x00\x12X\n" +
	"\x12ResetBlockAssembly\x12\x1f.blockassembly_api.EmptyMessage\x1a\x1f.blockassembly_api.EmptyMessage\"\x00\x12]\n" +
	"\x17ResetBlockAssemblyFully\x12\x1f.blockassembly_api.EmptyMessage\x1a\x1f.blockassembly_api.EmptyMessage\"\x00\x12[\n" +
	"\x15GetBlockAssemblyState\x12\x1f.blockassembly_api.EmptyMessage\x1a\x1f.blockassembly_api.StateMessage\"\x00\x12]\n" +
	"\x0eGenerateBlocks\x12(.blockassembly_api.GenerateBlocksRequest\x1a\x1f.blockassembly_api.EmptyMessage\"\x00\x12V\n" +
	"\x12CheckBlockAssembly\x12\x1f.blockassembly_api.EmptyMessage\x1a\x1d.blockassembly_api.OKResponse\"\x00\x12~\n" +
	"\x1eGetBlockAssemblyBlockCandidate\x12\x1f.blockassembly_api.EmptyMessage\x1a9.blockassembly_api.GetBlockAssemblyBlockCandidateResponse\"\x00\x12h\n" +
	"\x13GetBlockAssemblyTxs\x12\x1f.blockassembly_api.EmptyMessage\x1a..blockassembly_api.GetBlockAssemblyTxsResponse\"\x00B\x16Z\x14./;blockassembly_apib\x06proto3"

var (
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescOnce sync.Once
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescData []byte
)

func file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescGZIP() []byte {
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescOnce.Do(func() {
		file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDesc), len(file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDesc)))
	})
	return file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDescData
}

var file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
var file_services_blockassembly_blockassembly_api_blockassembly_api_proto_goTypes = []any{
	(*EmptyMessage)(nil),                           // 0: blockassembly_api.EmptyMessage
	(*HealthResponse)(nil),                         // 1: blockassembly_api.HealthResponse
	(*NewChaintipAndHeightRequest)(nil),            // 2: blockassembly_api.NewChaintipAndHeightRequest
	(*AddTxRequest)(nil),                           // 3: blockassembly_api.AddTxRequest
	(*AddTxBatchRequest)(nil),                      // 4: blockassembly_api.AddTxBatchRequest
	(*GetMiningCandidateRequest)(nil),              // 5: blockassembly_api.GetMiningCandidateRequest
	(*RemoveTxRequest)(nil),                        // 6: blockassembly_api.RemoveTxRequest
	(*AddTxResponse)(nil),                          // 7: blockassembly_api.AddTxResponse
	(*AddTxBatchResponse)(nil),                     // 8: blockassembly_api.AddTxBatchResponse
	(*SubmitMiningSolutionRequest)(nil),            // 9: blockassembly_api.SubmitMiningSolutionRequest
	(*OKResponse)(nil),                             // 10: blockassembly_api.OKResponse
	(*StateMessage)(nil),                           // 11: blockassembly_api.StateMessage
	(*GetCurrentDifficultyResponse)(nil),           // 12: blockassembly_api.GetCurrentDifficultyResponse
	(*GenerateBlocksRequest)(nil),                  // 13: blockassembly_api.GenerateBlocksRequest
	(*GetBlockAssemblyBlockCandidateResponse)(nil), // 14: blockassembly_api.GetBlockAssemblyBlockCandidateResponse
	(*GetBlockAssemblyTxsResponse)(nil),            // 15: blockassembly_api.GetBlockAssemblyTxsResponse
	(*timestamppb.Timestamp)(nil),                  // 16: google.protobuf.Timestamp
	(*model.MiningCandidate)(nil),                  // 17: model.MiningCandidate
}
var file_services_blockassembly_blockassembly_api_blockassembly_api_proto_depIdxs = []int32{
	16, // 0: blockassembly_api.HealthResponse.timestamp:type_name -> google.protobuf.Timestamp
	3,  // 1: blockassembly_api.AddTxBatchRequest.txRequests:type_name -> blockassembly_api.AddTxRequest
	0,  // 2: blockassembly_api.BlockAssemblyAPI.HealthGRPC:input_type -> blockassembly_api.EmptyMessage
	3,  // 3: blockassembly_api.BlockAssemblyAPI.AddTx:input_type -> blockassembly_api.AddTxRequest
	6,  // 4: blockassembly_api.BlockAssemblyAPI.RemoveTx:input_type -> blockassembly_api.RemoveTxRequest
	4,  // 5: blockassembly_api.BlockAssemblyAPI.AddTxBatch:input_type -> blockassembly_api.AddTxBatchRequest
	5,  // 6: blockassembly_api.BlockAssemblyAPI.GetMiningCandidate:input_type -> blockassembly_api.GetMiningCandidateRequest
	0,  // 7: blockassembly_api.BlockAssemblyAPI.GetCurrentDifficulty:input_type -> blockassembly_api.EmptyMessage
	9,  // 8: blockassembly_api.BlockAssemblyAPI.SubmitMiningSolution:input_type -> blockassembly_api.SubmitMiningSolutionRequest
	0,  // 9: blockassembly_api.BlockAssemblyAPI.ResetBlockAssembly:input_type -> blockassembly_api.EmptyMessage
	0,  // 10: blockassembly_api.BlockAssemblyAPI.ResetBlockAssemblyFully:input_type -> blockassembly_api.EmptyMessage
	0,  // 11: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyState:input_type -> blockassembly_api.EmptyMessage
	13, // 12: blockassembly_api.BlockAssemblyAPI.GenerateBlocks:input_type -> blockassembly_api.GenerateBlocksRequest
	0,  // 13: blockassembly_api.BlockAssemblyAPI.CheckBlockAssembly:input_type -> blockassembly_api.EmptyMessage
	0,  // 14: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyBlockCandidate:input_type -> blockassembly_api.EmptyMessage
	0,  // 15: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyTxs:input_type -> blockassembly_api.EmptyMessage
	1,  // 16: blockassembly_api.BlockAssemblyAPI.HealthGRPC:output_type -> blockassembly_api.HealthResponse
	7,  // 17: blockassembly_api.BlockAssemblyAPI.AddTx:output_type -> blockassembly_api.AddTxResponse
	0,  // 18: blockassembly_api.BlockAssemblyAPI.RemoveTx:output_type -> blockassembly_api.EmptyMessage
	8,  // 19: blockassembly_api.BlockAssemblyAPI.AddTxBatch:output_type -> blockassembly_api.AddTxBatchResponse
	17, // 20: blockassembly_api.BlockAssemblyAPI.GetMiningCandidate:output_type -> model.MiningCandidate
	12, // 21: blockassembly_api.BlockAssemblyAPI.GetCurrentDifficulty:output_type -> blockassembly_api.GetCurrentDifficultyResponse
	10, // 22: blockassembly_api.BlockAssemblyAPI.SubmitMiningSolution:output_type -> blockassembly_api.OKResponse
	0,  // 23: blockassembly_api.BlockAssemblyAPI.ResetBlockAssembly:output_type -> blockassembly_api.EmptyMessage
	0,  // 24: blockassembly_api.BlockAssemblyAPI.ResetBlockAssemblyFully:output_type -> blockassembly_api.EmptyMessage
	11, // 25: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyState:output_type -> blockassembly_api.StateMessage
	0,  // 26: blockassembly_api.BlockAssemblyAPI.GenerateBlocks:output_type -> blockassembly_api.EmptyMessage
	10, // 27: blockassembly_api.BlockAssemblyAPI.CheckBlockAssembly:output_type -> blockassembly_api.OKResponse
	14, // 28: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyBlockCandidate:output_type -> blockassembly_api.GetBlockAssemblyBlockCandidateResponse
	15, // 29: blockassembly_api.BlockAssemblyAPI.GetBlockAssemblyTxs:output_type -> blockassembly_api.GetBlockAssemblyTxsResponse
	16, // [16:30] is the sub-list for method output_type
	2,  // [2:16] is the sub-list for method input_type
	2,  // [2:2] is the sub-list for extension type_name
	2,  // [2:2] is the sub-list for extension extendee
	0,  // [0:2] is the sub-list for field type_name
}

func init() { file_services_blockassembly_blockassembly_api_blockassembly_api_proto_init() }
func file_services_blockassembly_blockassembly_api_blockassembly_api_proto_init() {
	if File_services_blockassembly_blockassembly_api_blockassembly_api_proto != nil {
		return
	}
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[9].OneofWrappers = []any{}
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes[13].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDesc), len(file_services_blockassembly_blockassembly_api_blockassembly_api_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   16,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_services_blockassembly_blockassembly_api_blockassembly_api_proto_goTypes,
		DependencyIndexes: file_services_blockassembly_blockassembly_api_blockassembly_api_proto_depIdxs,
		MessageInfos:      file_services_blockassembly_blockassembly_api_blockassembly_api_proto_msgTypes,
	}.Build()
	File_services_blockassembly_blockassembly_api_blockassembly_api_proto = out.File
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_goTypes = nil
	file_services_blockassembly_blockassembly_api_blockassembly_api_proto_depIdxs = nil
}
