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

package blockassembly_api

import (
	context "context"
	model "github.com/bsv-blockchain/teranode/model"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	BlockAssemblyAPI_HealthGRPC_FullMethodName                     = "/blockassembly_api.BlockAssemblyAPI/HealthGRPC"
	BlockAssemblyAPI_AddTx_FullMethodName                          = "/blockassembly_api.BlockAssemblyAPI/AddTx"
	BlockAssemblyAPI_RemoveTx_FullMethodName                       = "/blockassembly_api.BlockAssemblyAPI/RemoveTx"
	BlockAssemblyAPI_AddTxBatch_FullMethodName                     = "/blockassembly_api.BlockAssemblyAPI/AddTxBatch"
	BlockAssemblyAPI_GetMiningCandidate_FullMethodName             = "/blockassembly_api.BlockAssemblyAPI/GetMiningCandidate"
	BlockAssemblyAPI_GetCurrentDifficulty_FullMethodName           = "/blockassembly_api.BlockAssemblyAPI/GetCurrentDifficulty"
	BlockAssemblyAPI_SubmitMiningSolution_FullMethodName           = "/blockassembly_api.BlockAssemblyAPI/SubmitMiningSolution"
	BlockAssemblyAPI_ResetBlockAssembly_FullMethodName             = "/blockassembly_api.BlockAssemblyAPI/ResetBlockAssembly"
	BlockAssemblyAPI_ResetBlockAssemblyFully_FullMethodName        = "/blockassembly_api.BlockAssemblyAPI/ResetBlockAssemblyFully"
	BlockAssemblyAPI_GetBlockAssemblyState_FullMethodName          = "/blockassembly_api.BlockAssemblyAPI/GetBlockAssemblyState"
	BlockAssemblyAPI_GenerateBlocks_FullMethodName                 = "/blockassembly_api.BlockAssemblyAPI/GenerateBlocks"
	BlockAssemblyAPI_CheckBlockAssembly_FullMethodName             = "/blockassembly_api.BlockAssemblyAPI/CheckBlockAssembly"
	BlockAssemblyAPI_GetBlockAssemblyBlockCandidate_FullMethodName = "/blockassembly_api.BlockAssemblyAPI/GetBlockAssemblyBlockCandidate"
	BlockAssemblyAPI_GetBlockAssemblyTxs_FullMethodName            = "/blockassembly_api.BlockAssemblyAPI/GetBlockAssemblyTxs"
)

// BlockAssemblyAPIClient is the client API for BlockAssemblyAPI service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
//
// *
// BlockAssemblyAPI Service
// Responsible for assembling new blocks and managing the blockchain's block creation process.
// This service handles transaction management, mining operations, and block state management.
type BlockAssemblyAPIClient interface {
	// HealthGRPC checks the health status of the block assembly service.
	// Returns detailed health information including service status and timestamp.
	HealthGRPC(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*HealthResponse, error)
	// AddTx adds a single transaction to the next available subtree.
	// The transaction will be included in block assembly for mining.
	AddTx(ctx context.Context, in *AddTxRequest, opts ...grpc.CallOption) (*AddTxResponse, error)
	// RemoveTx removes a transaction from consideration for block inclusion.
	// This is useful for handling double-spends or invalid transactions.
	RemoveTx(ctx context.Context, in *RemoveTxRequest, opts ...grpc.CallOption) (*EmptyMessage, error)
	// AddTxBatch efficiently adds multiple transactions in a single request.
	// Provides better performance than multiple individual AddTx calls.
	AddTxBatch(ctx context.Context, in *AddTxBatchRequest, opts ...grpc.CallOption) (*AddTxBatchResponse, error)
	// GetMiningCandidate retrieves a block template ready for mining.
	// Includes all necessary components for miners to begin work.
	GetMiningCandidate(ctx context.Context, in *GetMiningCandidateRequest, opts ...grpc.CallOption) (*model.MiningCandidate, error)
	// GetCurrentDifficulty retrieves the current network mining difficulty.
	// Used by miners to understand the current mining requirements.
	GetCurrentDifficulty(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetCurrentDifficultyResponse, error)
	// SubmitMiningSolution submits a solved block to the network.
	// Includes the proof-of-work solution and block details.
	SubmitMiningSolution(ctx context.Context, in *SubmitMiningSolutionRequest, opts ...grpc.CallOption) (*OKResponse, error)
	// ResetBlockAssembly resets the block assembly state.
	// Useful for handling reorgs or recovering from errors.
	ResetBlockAssembly(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*EmptyMessage, error)
	// ResetBlockAssemblyFully performs a complete reset of the block assembly state.
	// This includes clearing all transactions and resetting internal structures.
	// This will traverse the whole UTXO set and is more intensive than a standard reset.
	ResetBlockAssemblyFully(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*EmptyMessage, error)
	// GetBlockAssemblyState retrieves the current state of block assembly.
	// Provides detailed information about the assembly process status.
	GetBlockAssemblyState(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*StateMessage, error)
	// GenerateBlocks creates new blocks (typically for testing purposes).
	// Allows specification of block count and recipient address.
	GenerateBlocks(ctx context.Context, in *GenerateBlocksRequest, opts ...grpc.CallOption) (*EmptyMessage, error)
	// CheckBlockAssembly checks the current state of block assembly.
	// This verifies that the block assembly and subtree processor are functioning correctly.
	CheckBlockAssembly(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*OKResponse, error)
	// CheckBlockAssembly checks the current state of block assembly.
	// This verifies that the block assembly and subtree processor are functioning correctly.
	GetBlockAssemblyBlockCandidate(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetBlockAssemblyBlockCandidateResponse, error)
	// GetBlockAssemblyTxs retrieves the transactions currently being assembled in the block assembly.
	// This provides visibility into the transactions that are candidates for inclusion in the next block.
	// NOTE: this method is primarily for debugging purposes and may not be suitable for production use.
	GetBlockAssemblyTxs(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetBlockAssemblyTxsResponse, error)
}

type blockAssemblyAPIClient struct {
	cc grpc.ClientConnInterface
}

func NewBlockAssemblyAPIClient(cc grpc.ClientConnInterface) BlockAssemblyAPIClient {
	return &blockAssemblyAPIClient{cc}
}

func (c *blockAssemblyAPIClient) HealthGRPC(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*HealthResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(HealthResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_HealthGRPC_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) AddTx(ctx context.Context, in *AddTxRequest, opts ...grpc.CallOption) (*AddTxResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddTxResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_AddTx_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) RemoveTx(ctx context.Context, in *RemoveTxRequest, opts ...grpc.CallOption) (*EmptyMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_RemoveTx_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) AddTxBatch(ctx context.Context, in *AddTxBatchRequest, opts ...grpc.CallOption) (*AddTxBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddTxBatchResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_AddTxBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GetMiningCandidate(ctx context.Context, in *GetMiningCandidateRequest, opts ...grpc.CallOption) (*model.MiningCandidate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(model.MiningCandidate)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GetMiningCandidate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GetCurrentDifficulty(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetCurrentDifficultyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCurrentDifficultyResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GetCurrentDifficulty_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) SubmitMiningSolution(ctx context.Context, in *SubmitMiningSolutionRequest, opts ...grpc.CallOption) (*OKResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OKResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_SubmitMiningSolution_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) ResetBlockAssembly(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*EmptyMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_ResetBlockAssembly_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) ResetBlockAssemblyFully(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*EmptyMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_ResetBlockAssemblyFully_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GetBlockAssemblyState(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*StateMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StateMessage)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GetBlockAssemblyState_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GenerateBlocks(ctx context.Context, in *GenerateBlocksRequest, opts ...grpc.CallOption) (*EmptyMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GenerateBlocks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) CheckBlockAssembly(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*OKResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OKResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_CheckBlockAssembly_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GetBlockAssemblyBlockCandidate(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetBlockAssemblyBlockCandidateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetBlockAssemblyBlockCandidateResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GetBlockAssemblyBlockCandidate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *blockAssemblyAPIClient) GetBlockAssemblyTxs(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*GetBlockAssemblyTxsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetBlockAssemblyTxsResponse)
	err := c.cc.Invoke(ctx, BlockAssemblyAPI_GetBlockAssemblyTxs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BlockAssemblyAPIServer is the server API for BlockAssemblyAPI service.
// All implementations must embed UnimplementedBlockAssemblyAPIServer
// for forward compatibility.
//
// *
// BlockAssemblyAPI Service
// Responsible for assembling new blocks and managing the blockchain's block creation process.
// This service handles transaction management, mining operations, and block state management.
type BlockAssemblyAPIServer interface {
	// HealthGRPC checks the health status of the block assembly service.
	// Returns detailed health information including service status and timestamp.
	HealthGRPC(context.Context, *EmptyMessage) (*HealthResponse, error)
	// AddTx adds a single transaction to the next available subtree.
	// The transaction will be included in block assembly for mining.
	AddTx(context.Context, *AddTxRequest) (*AddTxResponse, error)
	// RemoveTx removes a transaction from consideration for block inclusion.
	// This is useful for handling double-spends or invalid transactions.
	RemoveTx(context.Context, *RemoveTxRequest) (*EmptyMessage, error)
	// AddTxBatch efficiently adds multiple transactions in a single request.
	// Provides better performance than multiple individual AddTx calls.
	AddTxBatch(context.Context, *AddTxBatchRequest) (*AddTxBatchResponse, error)
	// GetMiningCandidate retrieves a block template ready for mining.
	// Includes all necessary components for miners to begin work.
	GetMiningCandidate(context.Context, *GetMiningCandidateRequest) (*model.MiningCandidate, error)
	// GetCurrentDifficulty retrieves the current network mining difficulty.
	// Used by miners to understand the current mining requirements.
	GetCurrentDifficulty(context.Context, *EmptyMessage) (*GetCurrentDifficultyResponse, error)
	// SubmitMiningSolution submits a solved block to the network.
	// Includes the proof-of-work solution and block details.
	SubmitMiningSolution(context.Context, *SubmitMiningSolutionRequest) (*OKResponse, error)
	// ResetBlockAssembly resets the block assembly state.
	// Useful for handling reorgs or recovering from errors.
	ResetBlockAssembly(context.Context, *EmptyMessage) (*EmptyMessage, error)
	// ResetBlockAssemblyFully performs a complete reset of the block assembly state.
	// This includes clearing all transactions and resetting internal structures.
	// This will traverse the whole UTXO set and is more intensive than a standard reset.
	ResetBlockAssemblyFully(context.Context, *EmptyMessage) (*EmptyMessage, error)
	// GetBlockAssemblyState retrieves the current state of block assembly.
	// Provides detailed information about the assembly process status.
	GetBlockAssemblyState(context.Context, *EmptyMessage) (*StateMessage, error)
	// GenerateBlocks creates new blocks (typically for testing purposes).
	// Allows specification of block count and recipient address.
	GenerateBlocks(context.Context, *GenerateBlocksRequest) (*EmptyMessage, error)
	// CheckBlockAssembly checks the current state of block assembly.
	// This verifies that the block assembly and subtree processor are functioning correctly.
	CheckBlockAssembly(context.Context, *EmptyMessage) (*OKResponse, error)
	// CheckBlockAssembly checks the current state of block assembly.
	// This verifies that the block assembly and subtree processor are functioning correctly.
	GetBlockAssemblyBlockCandidate(context.Context, *EmptyMessage) (*GetBlockAssemblyBlockCandidateResponse, error)
	// GetBlockAssemblyTxs retrieves the transactions currently being assembled in the block assembly.
	// This provides visibility into the transactions that are candidates for inclusion in the next block.
	// NOTE: this method is primarily for debugging purposes and may not be suitable for production use.
	GetBlockAssemblyTxs(context.Context, *EmptyMessage) (*GetBlockAssemblyTxsResponse, error)
	mustEmbedUnimplementedBlockAssemblyAPIServer()
}

// UnimplementedBlockAssemblyAPIServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedBlockAssemblyAPIServer struct{}

func (UnimplementedBlockAssemblyAPIServer) HealthGRPC(context.Context, *EmptyMessage) (*HealthResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HealthGRPC not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) AddTx(context.Context, *AddTxRequest) (*AddTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddTx not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) RemoveTx(context.Context, *RemoveTxRequest) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveTx not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) AddTxBatch(context.Context, *AddTxBatchRequest) (*AddTxBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddTxBatch not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GetMiningCandidate(context.Context, *GetMiningCandidateRequest) (*model.MiningCandidate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMiningCandidate not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GetCurrentDifficulty(context.Context, *EmptyMessage) (*GetCurrentDifficultyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCurrentDifficulty not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) SubmitMiningSolution(context.Context, *SubmitMiningSolutionRequest) (*OKResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitMiningSolution not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) ResetBlockAssembly(context.Context, *EmptyMessage) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetBlockAssembly not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) ResetBlockAssemblyFully(context.Context, *EmptyMessage) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetBlockAssemblyFully not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GetBlockAssemblyState(context.Context, *EmptyMessage) (*StateMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlockAssemblyState not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GenerateBlocks(context.Context, *GenerateBlocksRequest) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateBlocks not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) CheckBlockAssembly(context.Context, *EmptyMessage) (*OKResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckBlockAssembly not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GetBlockAssemblyBlockCandidate(context.Context, *EmptyMessage) (*GetBlockAssemblyBlockCandidateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlockAssemblyBlockCandidate not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) GetBlockAssemblyTxs(context.Context, *EmptyMessage) (*GetBlockAssemblyTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlockAssemblyTxs not implemented")
}
func (UnimplementedBlockAssemblyAPIServer) mustEmbedUnimplementedBlockAssemblyAPIServer() {}
func (UnimplementedBlockAssemblyAPIServer) testEmbeddedByValue()                          {}

// UnsafeBlockAssemblyAPIServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to BlockAssemblyAPIServer will
// result in compilation errors.
type UnsafeBlockAssemblyAPIServer interface {
	mustEmbedUnimplementedBlockAssemblyAPIServer()
}

func RegisterBlockAssemblyAPIServer(s grpc.ServiceRegistrar, srv BlockAssemblyAPIServer) {
	// If the following call pancis, it indicates UnimplementedBlockAssemblyAPIServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&BlockAssemblyAPI_ServiceDesc, srv)
}

func _BlockAssemblyAPI_HealthGRPC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).HealthGRPC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_HealthGRPC_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).HealthGRPC(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_AddTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).AddTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_AddTx_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).AddTx(ctx, req.(*AddTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_RemoveTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).RemoveTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_RemoveTx_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).RemoveTx(ctx, req.(*RemoveTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_AddTxBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTxBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).AddTxBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_AddTxBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).AddTxBatch(ctx, req.(*AddTxBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GetMiningCandidate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMiningCandidateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GetMiningCandidate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GetMiningCandidate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GetMiningCandidate(ctx, req.(*GetMiningCandidateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GetCurrentDifficulty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GetCurrentDifficulty(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GetCurrentDifficulty_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GetCurrentDifficulty(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_SubmitMiningSolution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitMiningSolutionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).SubmitMiningSolution(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_SubmitMiningSolution_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).SubmitMiningSolution(ctx, req.(*SubmitMiningSolutionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_ResetBlockAssembly_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).ResetBlockAssembly(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_ResetBlockAssembly_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).ResetBlockAssembly(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_ResetBlockAssemblyFully_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).ResetBlockAssemblyFully(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_ResetBlockAssemblyFully_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).ResetBlockAssemblyFully(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GetBlockAssemblyState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GetBlockAssemblyState_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyState(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GenerateBlocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateBlocksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GenerateBlocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GenerateBlocks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GenerateBlocks(ctx, req.(*GenerateBlocksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_CheckBlockAssembly_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).CheckBlockAssembly(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_CheckBlockAssembly_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).CheckBlockAssembly(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GetBlockAssemblyBlockCandidate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyBlockCandidate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GetBlockAssemblyBlockCandidate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyBlockCandidate(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _BlockAssemblyAPI_GetBlockAssemblyTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BlockAssemblyAPI_GetBlockAssemblyTxs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BlockAssemblyAPIServer).GetBlockAssemblyTxs(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

// BlockAssemblyAPI_ServiceDesc is the grpc.ServiceDesc for BlockAssemblyAPI service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var BlockAssemblyAPI_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "blockassembly_api.BlockAssemblyAPI",
	HandlerType: (*BlockAssemblyAPIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "HealthGRPC",
			Handler:    _BlockAssemblyAPI_HealthGRPC_Handler,
		},
		{
			MethodName: "AddTx",
			Handler:    _BlockAssemblyAPI_AddTx_Handler,
		},
		{
			MethodName: "RemoveTx",
			Handler:    _BlockAssemblyAPI_RemoveTx_Handler,
		},
		{
			MethodName: "AddTxBatch",
			Handler:    _BlockAssemblyAPI_AddTxBatch_Handler,
		},
		{
			MethodName: "GetMiningCandidate",
			Handler:    _BlockAssemblyAPI_GetMiningCandidate_Handler,
		},
		{
			MethodName: "GetCurrentDifficulty",
			Handler:    _BlockAssemblyAPI_GetCurrentDifficulty_Handler,
		},
		{
			MethodName: "SubmitMiningSolution",
			Handler:    _BlockAssemblyAPI_SubmitMiningSolution_Handler,
		},
		{
			MethodName: "ResetBlockAssembly",
			Handler:    _BlockAssemblyAPI_ResetBlockAssembly_Handler,
		},
		{
			MethodName: "ResetBlockAssemblyFully",
			Handler:    _BlockAssemblyAPI_ResetBlockAssemblyFully_Handler,
		},
		{
			MethodName: "GetBlockAssemblyState",
			Handler:    _BlockAssemblyAPI_GetBlockAssemblyState_Handler,
		},
		{
			MethodName: "GenerateBlocks",
			Handler:    _BlockAssemblyAPI_GenerateBlocks_Handler,
		},
		{
			MethodName: "CheckBlockAssembly",
			Handler:    _BlockAssemblyAPI_CheckBlockAssembly_Handler,
		},
		{
			MethodName: "GetBlockAssemblyBlockCandidate",
			Handler:    _BlockAssemblyAPI_GetBlockAssemblyBlockCandidate_Handler,
		},
		{
			MethodName: "GetBlockAssemblyTxs",
			Handler:    _BlockAssemblyAPI_GetBlockAssemblyTxs_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "services/blockassembly/blockassembly_api/blockassembly_api.proto",
}
