func (m *MocklayerDB) GetLayerInputVectorByID(arg0 types.LayerID) ([]types.BlockID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerInputVectorByID", arg0)
	ret0, _ := ret[0].([]types.BlockID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
GetLayerInputVectorByID mocks base method.
package mocks
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	network "github.com/libp2p/go-libp2p-core/network"
	peer "github.com/libp2p/go-libp2p-core/peer"
	protocol "github.com/libp2p/go-libp2p-core/protocol"
	types "github.com/spacemeshos/go-spacemesh/common/types"
)
type MockatxHandler struct {
	ctrl     *gomock.Controller
	recorder *MockatxHandlerMockRecorder
}
type MockatxHandlerMockRecorder struct {
	mock *MockatxHandler
}
func NewMockatxHandler(ctrl *gomock.Controller) *MockatxHandler {
	mock := &MockatxHandler{ctrl: ctrl}
	mock.recorder = &MockatxHandlerMockRecorder{mock}
	return mock
}
func (m *MockatxHandler) EXPECT() *MockatxHandlerMockRecorder {
	return m.recorder
}
func (m *MockatxHandler) HandleAtxData(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleAtxData", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockatxHandlerMockRecorder) HandleAtxData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAtxData", reflect.TypeOf((*MockatxHandler)(nil).HandleAtxData), arg0, arg1)
}
type MockblockHandler struct {
	ctrl     *gomock.Controller
	recorder *MockblockHandlerMockRecorder
}
type MockblockHandlerMockRecorder struct {
	mock *MockblockHandler
}
func NewMockblockHandler(ctrl *gomock.Controller) *MockblockHandler {
	mock := &MockblockHandler{ctrl: ctrl}
	mock.recorder = &MockblockHandlerMockRecorder{mock}
	return mock
}
func (m *MockblockHandler) EXPECT() *MockblockHandlerMockRecorder {
	return m.recorder
}
func (m *MockblockHandler) HandleBlockData(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleBlockData", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockblockHandlerMockRecorder) HandleBlockData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleBlockData", reflect.TypeOf((*MockblockHandler)(nil).HandleBlockData), arg0, arg1)
}
type MockTxProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockTxProcessorMockRecorder
}
type MockTxProcessorMockRecorder struct {
	mock *MockTxProcessor
}
func NewMockTxProcessor(ctrl *gomock.Controller) *MockTxProcessor {
	mock := &MockTxProcessor{ctrl: ctrl}
	mock.recorder = &MockTxProcessorMockRecorder{mock}
	return mock
}
func (m *MockTxProcessor) EXPECT() *MockTxProcessorMockRecorder {
	return m.recorder
}
func (m *MockTxProcessor) HandleTxSyncData(data []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleTxSyncData", data)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockTxProcessorMockRecorder) HandleTxSyncData(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleTxSyncData", reflect.TypeOf((*MockTxProcessor)(nil).HandleTxSyncData), data)
}
type MocklayerDB struct {
	ctrl     *gomock.Controller
	recorder *MocklayerDBMockRecorder
}
type MocklayerDBMockRecorder struct {
	mock *MocklayerDB
}
func NewMocklayerDB(ctrl *gomock.Controller) *MocklayerDB {
	mock := &MocklayerDB{ctrl: ctrl}
	mock.recorder = &MocklayerDBMockRecorder{mock}
	return mock
}
func (m *MocklayerDB) EXPECT() *MocklayerDBMockRecorder {
	return m.recorder
}
func (m *MocklayerDB) GetAggregatedLayerHash(arg0 types.LayerID) types.Hash32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAggregatedLayerHash", arg0)
	ret0, _ := ret[0].(types.Hash32)
	return ret0
}
func (mr *MocklayerDBMockRecorder) GetAggregatedLayerHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregatedLayerHash", reflect.TypeOf((*MocklayerDB)(nil).GetAggregatedLayerHash), arg0)
}
func (m *MocklayerDB) GetLayerHash(arg0 types.LayerID) types.Hash32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerHash", arg0)
	ret0, _ := ret[0].(types.Hash32)
	return ret0
}
func (mr *MocklayerDBMockRecorder) GetLayerHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerHash", reflect.TypeOf((*MocklayerDB)(nil).GetLayerHash), arg0)
}