// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ava-labs/avalanchego/snow/engine/snowman/block (interfaces: ChainVM)
//
// Generated by this command:
//
//	mockgen -package=blockmock -destination=blockmock/chain_vm.go -mock_names=ChainVM=ChainVM . ChainVM
//

// Package blockmock is a generated GoMock package.
package blockmock

import (
	context "context"
	http "net/http"
	reflect "reflect"
	time "time"

	database "github.com/ava-labs/avalanchego/database"
	ids "github.com/ava-labs/avalanchego/ids"
	snow "github.com/ava-labs/avalanchego/snow"
	snowman "github.com/ava-labs/avalanchego/snow/consensus/snowman"
	common "github.com/ava-labs/avalanchego/snow/engine/common"
	version "github.com/ava-labs/avalanchego/version"
	gomock "go.uber.org/mock/gomock"
)

// ChainVM is a mock of ChainVM interface.
type ChainVM struct {
	ctrl     *gomock.Controller
	recorder *ChainVMMockRecorder
	isgomock struct{}
}

// ChainVMMockRecorder is the mock recorder for ChainVM.
type ChainVMMockRecorder struct {
	mock *ChainVM
}

// NewChainVM creates a new mock instance.
func NewChainVM(ctrl *gomock.Controller) *ChainVM {
	mock := &ChainVM{ctrl: ctrl}
	mock.recorder = &ChainVMMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *ChainVM) EXPECT() *ChainVMMockRecorder {
	return m.recorder
}

// AppGossip mocks base method.
func (m *ChainVM) AppGossip(ctx context.Context, nodeID ids.NodeID, msg []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppGossip", ctx, nodeID, msg)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppGossip indicates an expected call of AppGossip.
func (mr *ChainVMMockRecorder) AppGossip(ctx, nodeID, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppGossip", reflect.TypeOf((*ChainVM)(nil).AppGossip), ctx, nodeID, msg)
}

// AppRequest mocks base method.
func (m *ChainVM) AppRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, deadline time.Time, request []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppRequest", ctx, nodeID, requestID, deadline, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppRequest indicates an expected call of AppRequest.
func (mr *ChainVMMockRecorder) AppRequest(ctx, nodeID, requestID, deadline, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppRequest", reflect.TypeOf((*ChainVM)(nil).AppRequest), ctx, nodeID, requestID, deadline, request)
}

// AppRequestFailed mocks base method.
func (m *ChainVM) AppRequestFailed(ctx context.Context, nodeID ids.NodeID, requestID uint32, appErr *common.AppError) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppRequestFailed", ctx, nodeID, requestID, appErr)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppRequestFailed indicates an expected call of AppRequestFailed.
func (mr *ChainVMMockRecorder) AppRequestFailed(ctx, nodeID, requestID, appErr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppRequestFailed", reflect.TypeOf((*ChainVM)(nil).AppRequestFailed), ctx, nodeID, requestID, appErr)
}

// AppResponse mocks base method.
func (m *ChainVM) AppResponse(ctx context.Context, nodeID ids.NodeID, requestID uint32, response []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppResponse", ctx, nodeID, requestID, response)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppResponse indicates an expected call of AppResponse.
func (mr *ChainVMMockRecorder) AppResponse(ctx, nodeID, requestID, response any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppResponse", reflect.TypeOf((*ChainVM)(nil).AppResponse), ctx, nodeID, requestID, response)
}

// BuildBlock mocks base method.
func (m *ChainVM) BuildBlock(arg0 context.Context) (snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildBlock", arg0)
	ret0, _ := ret[0].(snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildBlock indicates an expected call of BuildBlock.
func (mr *ChainVMMockRecorder) BuildBlock(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildBlock", reflect.TypeOf((*ChainVM)(nil).BuildBlock), arg0)
}

// Connected mocks base method.
func (m *ChainVM) Connected(ctx context.Context, nodeID ids.NodeID, nodeVersion *version.Application) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", ctx, nodeID, nodeVersion)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *ChainVMMockRecorder) Connected(ctx, nodeID, nodeVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*ChainVM)(nil).Connected), ctx, nodeID, nodeVersion)
}

// CreateHandlers mocks base method.
func (m *ChainVM) CreateHandlers(arg0 context.Context) (map[string]http.Handler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHandlers", arg0)
	ret0, _ := ret[0].(map[string]http.Handler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHandlers indicates an expected call of CreateHandlers.
func (mr *ChainVMMockRecorder) CreateHandlers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHandlers", reflect.TypeOf((*ChainVM)(nil).CreateHandlers), arg0)
}

// Disconnected mocks base method.
func (m *ChainVM) Disconnected(ctx context.Context, nodeID ids.NodeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Disconnected", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Disconnected indicates an expected call of Disconnected.
func (mr *ChainVMMockRecorder) Disconnected(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnected", reflect.TypeOf((*ChainVM)(nil).Disconnected), ctx, nodeID)
}

// GetBlock mocks base method.
func (m *ChainVM) GetBlock(ctx context.Context, blkID ids.ID) (snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlock", ctx, blkID)
	ret0, _ := ret[0].(snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlock indicates an expected call of GetBlock.
func (mr *ChainVMMockRecorder) GetBlock(ctx, blkID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlock", reflect.TypeOf((*ChainVM)(nil).GetBlock), ctx, blkID)
}

// GetBlockIDAtHeight mocks base method.
func (m *ChainVM) GetBlockIDAtHeight(ctx context.Context, height uint64) (ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockIDAtHeight", ctx, height)
	ret0, _ := ret[0].(ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockIDAtHeight indicates an expected call of GetBlockIDAtHeight.
func (mr *ChainVMMockRecorder) GetBlockIDAtHeight(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockIDAtHeight", reflect.TypeOf((*ChainVM)(nil).GetBlockIDAtHeight), ctx, height)
}

// HealthCheck mocks base method.
func (m *ChainVM) HealthCheck(arg0 context.Context) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HealthCheck", arg0)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HealthCheck indicates an expected call of HealthCheck.
func (mr *ChainVMMockRecorder) HealthCheck(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthCheck", reflect.TypeOf((*ChainVM)(nil).HealthCheck), arg0)
}

// Initialize mocks base method.
func (m *ChainVM) Initialize(ctx context.Context, chainCtx *snow.Context, db database.Database, genesisBytes, upgradeBytes, configBytes []byte, fxs []*common.Fx, appSender common.AppSender) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *ChainVMMockRecorder) Initialize(ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*ChainVM)(nil).Initialize), ctx, chainCtx, db, genesisBytes, upgradeBytes, configBytes, fxs, appSender)
}

// LastAccepted mocks base method.
func (m *ChainVM) LastAccepted(arg0 context.Context) (ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastAccepted", arg0)
	ret0, _ := ret[0].(ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastAccepted indicates an expected call of LastAccepted.
func (mr *ChainVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*ChainVM)(nil).LastAccepted), arg0)
}

// NewHTTPHandler mocks base method.
func (m *ChainVM) NewHTTPHandler(ctx context.Context) (http.Handler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewHTTPHandler", ctx)
	ret0, _ := ret[0].(http.Handler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewHTTPHandler indicates an expected call of NewHTTPHandler.
func (mr *ChainVMMockRecorder) NewHTTPHandler(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewHTTPHandler", reflect.TypeOf((*ChainVM)(nil).NewHTTPHandler), ctx)
}

// ParseBlock mocks base method.
func (m *ChainVM) ParseBlock(ctx context.Context, blockBytes []byte) (snowman.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseBlock", ctx, blockBytes)
	ret0, _ := ret[0].(snowman.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseBlock indicates an expected call of ParseBlock.
func (mr *ChainVMMockRecorder) ParseBlock(ctx, blockBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseBlock", reflect.TypeOf((*ChainVM)(nil).ParseBlock), ctx, blockBytes)
}

// SetPreference mocks base method.
func (m *ChainVM) SetPreference(ctx context.Context, blkID ids.ID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPreference", ctx, blkID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetPreference indicates an expected call of SetPreference.
func (mr *ChainVMMockRecorder) SetPreference(ctx, blkID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreference", reflect.TypeOf((*ChainVM)(nil).SetPreference), ctx, blkID)
}

// SetState mocks base method.
func (m *ChainVM) SetState(ctx context.Context, state snow.State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetState", ctx, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetState indicates an expected call of SetState.
func (mr *ChainVMMockRecorder) SetState(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*ChainVM)(nil).SetState), ctx, state)
}

// Shutdown mocks base method.
func (m *ChainVM) Shutdown(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Shutdown", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Shutdown indicates an expected call of Shutdown.
func (mr *ChainVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*ChainVM)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *ChainVM) Version(arg0 context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Version", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Version indicates an expected call of Version.
func (mr *ChainVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*ChainVM)(nil).Version), arg0)
}

// WaitForEvent mocks base method.
func (m *ChainVM) WaitForEvent(ctx context.Context) (common.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForEvent", ctx)
	ret0, _ := ret[0].(common.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitForEvent indicates an expected call of WaitForEvent.
func (mr *ChainVMMockRecorder) WaitForEvent(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForEvent", reflect.TypeOf((*ChainVM)(nil).WaitForEvent), ctx)
}
