vm/chain/blockmock/block_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: interfaces.go
//
// Generated by this command:
//
//	mockgen -source=interfaces.go -destination=blockmock/block_mock.go -package=blockmock
//

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

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

	ids "github.com/luxfi/ids"
	runtime "github.com/luxfi/runtime"
	vm "github.com/luxfi/vm"
	chain "github.com/luxfi/vm/chain"
	gomock "go.uber.org/mock/gomock"
)

// MockBlock is a mock of Block interface.
type MockBlock struct {
	ctrl     *gomock.Controller
	recorder *MockBlockMockRecorder
	isgomock struct{}
}

// MockBlockMockRecorder is the mock recorder for MockBlock.
type MockBlockMockRecorder struct {
	mock *MockBlock
}

// NewMockBlock creates a new mock instance.
func NewMockBlock(ctrl *gomock.Controller) *MockBlock {
	mock := &MockBlock{ctrl: ctrl}
	mock.recorder = &MockBlockMockRecorder{mock}
	return mock
}

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

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

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

// Bytes mocks base method.
func (m *MockBlock) Bytes() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bytes")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Bytes indicates an expected call of Bytes.
func (mr *MockBlockMockRecorder) Bytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockBlock)(nil).Bytes))
}

// Height mocks base method.
func (m *MockBlock) Height() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Height")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Height indicates an expected call of Height.
func (mr *MockBlockMockRecorder) Height() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockBlock)(nil).Height))
}

// ID mocks base method.
func (m *MockBlock) ID() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockBlockMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockBlock)(nil).ID))
}

// Parent mocks base method.
func (m *MockBlock) Parent() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parent")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// Parent indicates an expected call of Parent.
func (mr *MockBlockMockRecorder) Parent() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parent", reflect.TypeOf((*MockBlock)(nil).Parent))
}

// ParentID mocks base method.
func (m *MockBlock) ParentID() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParentID")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// ParentID indicates an expected call of ParentID.
func (mr *MockBlockMockRecorder) ParentID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParentID", reflect.TypeOf((*MockBlock)(nil).ParentID))
}

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

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

// Status mocks base method.
func (m *MockBlock) Status() uint8 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(uint8)
	return ret0
}

// Status indicates an expected call of Status.
func (mr *MockBlockMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockBlock)(nil).Status))
}

// Timestamp mocks base method.
func (m *MockBlock) Timestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockBlockMockRecorder) Timestamp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockBlock)(nil).Timestamp))
}

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

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

// MockSignedBlock is a mock of SignedBlock interface.
type MockSignedBlock struct {
	ctrl     *gomock.Controller
	recorder *MockSignedBlockMockRecorder
	isgomock struct{}
}

// MockSignedBlockMockRecorder is the mock recorder for MockSignedBlock.
type MockSignedBlockMockRecorder struct {
	mock *MockSignedBlock
}

// NewMockSignedBlock creates a new mock instance.
func NewMockSignedBlock(ctrl *gomock.Controller) *MockSignedBlock {
	mock := &MockSignedBlock{ctrl: ctrl}
	mock.recorder = &MockSignedBlockMockRecorder{mock}
	return mock
}

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

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

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

// Bytes mocks base method.
func (m *MockSignedBlock) Bytes() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bytes")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Bytes indicates an expected call of Bytes.
func (mr *MockSignedBlockMockRecorder) Bytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockSignedBlock)(nil).Bytes))
}

// Height mocks base method.
func (m *MockSignedBlock) Height() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Height")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Height indicates an expected call of Height.
func (mr *MockSignedBlockMockRecorder) Height() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockSignedBlock)(nil).Height))
}

// ID mocks base method.
func (m *MockSignedBlock) ID() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockSignedBlockMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockSignedBlock)(nil).ID))
}

// PChainEpoch mocks base method.
func (m *MockSignedBlock) PChainEpoch() chain.Epoch {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PChainEpoch")
	ret0, _ := ret[0].(chain.Epoch)
	return ret0
}

// PChainEpoch indicates an expected call of PChainEpoch.
func (mr *MockSignedBlockMockRecorder) PChainEpoch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PChainEpoch", reflect.TypeOf((*MockSignedBlock)(nil).PChainEpoch))
}

// PChainHeight mocks base method.
func (m *MockSignedBlock) PChainHeight() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PChainHeight")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// PChainHeight indicates an expected call of PChainHeight.
func (mr *MockSignedBlockMockRecorder) PChainHeight() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PChainHeight", reflect.TypeOf((*MockSignedBlock)(nil).PChainHeight))
}

// Parent mocks base method.
func (m *MockSignedBlock) Parent() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parent")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// Parent indicates an expected call of Parent.
func (mr *MockSignedBlockMockRecorder) Parent() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parent", reflect.TypeOf((*MockSignedBlock)(nil).Parent))
}

// ParentID mocks base method.
func (m *MockSignedBlock) ParentID() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParentID")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// ParentID indicates an expected call of ParentID.
func (mr *MockSignedBlockMockRecorder) ParentID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParentID", reflect.TypeOf((*MockSignedBlock)(nil).ParentID))
}

// Proposer mocks base method.
func (m *MockSignedBlock) Proposer() ids.NodeID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proposer")
	ret0, _ := ret[0].(ids.NodeID)
	return ret0
}

// Proposer indicates an expected call of Proposer.
func (mr *MockSignedBlockMockRecorder) Proposer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Proposer", reflect.TypeOf((*MockSignedBlock)(nil).Proposer))
}

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

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

// Status mocks base method.
func (m *MockSignedBlock) Status() uint8 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(uint8)
	return ret0
}

// Status indicates an expected call of Status.
func (mr *MockSignedBlockMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockSignedBlock)(nil).Status))
}

// Timestamp mocks base method.
func (m *MockSignedBlock) Timestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockSignedBlockMockRecorder) Timestamp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockSignedBlock)(nil).Timestamp))
}

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

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

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

// MockChainVMMockRecorder is the mock recorder for MockChainVM.
type MockChainVMMockRecorder struct {
	mock *MockChainVM
}

// NewMockChainVM creates a new mock instance.
func NewMockChainVM(ctrl *gomock.Controller) *MockChainVM {
	mock := &MockChainVM{ctrl: ctrl}
	mock.recorder = &MockChainVMMockRecorder{mock}
	return mock
}

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

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

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

// Connected mocks base method.
func (m *MockChainVM) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockChainVMMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockChainVM)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockChainVM) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockChainVM) 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 *MockChainVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockChainVM)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockChainVM) 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 *MockChainVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockChainVM)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockChainVM) 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 *MockChainVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockChainVM)(nil).Version), arg0)
}

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

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

// MockStateSyncableVM is a mock of StateSyncableVM interface.
type MockStateSyncableVM struct {
	ctrl     *gomock.Controller
	recorder *MockStateSyncableVMMockRecorder
	isgomock struct{}
}

// MockStateSyncableVMMockRecorder is the mock recorder for MockStateSyncableVM.
type MockStateSyncableVMMockRecorder struct {
	mock *MockStateSyncableVM
}

// NewMockStateSyncableVM creates a new mock instance.
func NewMockStateSyncableVM(ctrl *gomock.Controller) *MockStateSyncableVM {
	mock := &MockStateSyncableVM{ctrl: ctrl}
	mock.recorder = &MockStateSyncableVMMockRecorder{mock}
	return mock
}

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

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

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

// Connected mocks base method.
func (m *MockStateSyncableVM) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockStateSyncableVMMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockStateSyncableVM)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

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

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

// GetStateSummary mocks base method.
func (m *MockStateSyncableVM) GetStateSummary(arg0 context.Context, arg1 uint64) (chain.StateSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStateSummary", arg0, arg1)
	ret0, _ := ret[0].(chain.StateSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Initialize mocks base method.
func (m *MockStateSyncableVM) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockStateSyncableVM) 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 *MockStateSyncableVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockStateSyncableVM)(nil).LastAccepted), arg0)
}

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

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

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

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

// ParseStateSummary mocks base method.
func (m *MockStateSyncableVM) ParseStateSummary(arg0 context.Context, arg1 []byte) (chain.StateSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseStateSummary", arg0, arg1)
	ret0, _ := ret[0].(chain.StateSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockStateSyncableVM) 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 *MockStateSyncableVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockStateSyncableVM)(nil).Shutdown), arg0)
}

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

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

// Version mocks base method.
func (m *MockStateSyncableVM) 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 *MockStateSyncableVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockStateSyncableVM)(nil).Version), arg0)
}

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

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

// MockStateSummary is a mock of StateSummary interface.
type MockStateSummary struct {
	ctrl     *gomock.Controller
	recorder *MockStateSummaryMockRecorder
	isgomock struct{}
}

// MockStateSummaryMockRecorder is the mock recorder for MockStateSummary.
type MockStateSummaryMockRecorder struct {
	mock *MockStateSummary
}

// NewMockStateSummary creates a new mock instance.
func NewMockStateSummary(ctrl *gomock.Controller) *MockStateSummary {
	mock := &MockStateSummary{ctrl: ctrl}
	mock.recorder = &MockStateSummaryMockRecorder{mock}
	return mock
}

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

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

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

// Bytes mocks base method.
func (m *MockStateSummary) Bytes() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bytes")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Bytes indicates an expected call of Bytes.
func (mr *MockStateSummaryMockRecorder) Bytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockStateSummary)(nil).Bytes))
}

// Height mocks base method.
func (m *MockStateSummary) Height() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Height")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Height indicates an expected call of Height.
func (mr *MockStateSummaryMockRecorder) Height() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockStateSummary)(nil).Height))
}

// ID mocks base method.
func (m *MockStateSummary) ID() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockStateSummaryMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockStateSummary)(nil).ID))
}

// MockBuildBlockWithRuntimeChainVM is a mock of BuildBlockWithRuntimeChainVM interface.
type MockBuildBlockWithRuntimeChainVM struct {
	ctrl     *gomock.Controller
	recorder *MockBuildBlockWithRuntimeChainVMMockRecorder
	isgomock struct{}
}

// MockBuildBlockWithRuntimeChainVMMockRecorder is the mock recorder for MockBuildBlockWithRuntimeChainVM.
type MockBuildBlockWithRuntimeChainVMMockRecorder struct {
	mock *MockBuildBlockWithRuntimeChainVM
}

// NewMockBuildBlockWithRuntimeChainVM creates a new mock instance.
func NewMockBuildBlockWithRuntimeChainVM(ctrl *gomock.Controller) *MockBuildBlockWithRuntimeChainVM {
	mock := &MockBuildBlockWithRuntimeChainVM{ctrl: ctrl}
	mock.recorder = &MockBuildBlockWithRuntimeChainVMMockRecorder{mock}
	return mock
}

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

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

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

// BuildBlockWithRuntime mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) BuildBlockWithRuntime(arg0 context.Context, arg1 *runtime.Runtime) (chain.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildBlockWithRuntime", arg0, arg1)
	ret0, _ := ret[0].(chain.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Connected mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockBuildBlockWithRuntimeChainVMMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockBuildBlockWithRuntimeChainVM)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) 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 *MockBuildBlockWithRuntimeChainVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockBuildBlockWithRuntimeChainVM)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) 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 *MockBuildBlockWithRuntimeChainVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockBuildBlockWithRuntimeChainVM)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockBuildBlockWithRuntimeChainVM) 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 *MockBuildBlockWithRuntimeChainVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockBuildBlockWithRuntimeChainVM)(nil).Version), arg0)
}

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

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

// MockBuildBlockWithContextChainVM is a mock of BuildBlockWithContextChainVM interface.
type MockBuildBlockWithContextChainVM struct {
	ctrl     *gomock.Controller
	recorder *MockBuildBlockWithContextChainVMMockRecorder
	isgomock struct{}
}

// MockBuildBlockWithContextChainVMMockRecorder is the mock recorder for MockBuildBlockWithContextChainVM.
type MockBuildBlockWithContextChainVMMockRecorder struct {
	mock *MockBuildBlockWithContextChainVM
}

// NewMockBuildBlockWithContextChainVM creates a new mock instance.
func NewMockBuildBlockWithContextChainVM(ctrl *gomock.Controller) *MockBuildBlockWithContextChainVM {
	mock := &MockBuildBlockWithContextChainVM{ctrl: ctrl}
	mock.recorder = &MockBuildBlockWithContextChainVMMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Connected mocks base method.
func (m *MockBuildBlockWithContextChainVM) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockBuildBlockWithContextChainVMMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockBuildBlockWithContextChainVM)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockBuildBlockWithContextChainVM) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockBuildBlockWithContextChainVM) 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 *MockBuildBlockWithContextChainVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockBuildBlockWithContextChainVM)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockBuildBlockWithContextChainVM) 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 *MockBuildBlockWithContextChainVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockBuildBlockWithContextChainVM)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockBuildBlockWithContextChainVM) 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 *MockBuildBlockWithContextChainVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockBuildBlockWithContextChainVM)(nil).Version), arg0)
}

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

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

// MockBatchedChainVM is a mock of BatchedChainVM interface.
type MockBatchedChainVM struct {
	ctrl     *gomock.Controller
	recorder *MockBatchedChainVMMockRecorder
	isgomock struct{}
}

// MockBatchedChainVMMockRecorder is the mock recorder for MockBatchedChainVM.
type MockBatchedChainVMMockRecorder struct {
	mock *MockBatchedChainVM
}

// NewMockBatchedChainVM creates a new mock instance.
func NewMockBatchedChainVM(ctrl *gomock.Controller) *MockBatchedChainVM {
	mock := &MockBatchedChainVM{ctrl: ctrl}
	mock.recorder = &MockBatchedChainVMMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Connected mocks base method.
func (m *MockBatchedChainVM) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockBatchedChainVMMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockBatchedChainVM)(nil).Connected), arg0, arg1, arg2)
}

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

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

// GetAncestors mocks base method.
func (m *MockBatchedChainVM) GetAncestors(ctx context.Context, blkID ids.ID, maxBlocksNum, maxBlocksSize int, maxBlocksRetrievalTime time.Duration) ([][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAncestors", ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrievalTime)
	ret0, _ := ret[0].([][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAncestors indicates an expected call of GetAncestors.
func (mr *MockBatchedChainVMMockRecorder) GetAncestors(ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrievalTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAncestors", reflect.TypeOf((*MockBatchedChainVM)(nil).GetAncestors), ctx, blkID, maxBlocksNum, maxBlocksSize, maxBlocksRetrievalTime)
}

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockBatchedChainVM) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockBatchedChainVM) 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 *MockBatchedChainVMMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockBatchedChainVM)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockBatchedChainVM) 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 *MockBatchedChainVMMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockBatchedChainVM)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockBatchedChainVM) 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 *MockBatchedChainVMMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockBatchedChainVM)(nil).Version), arg0)
}

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

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

// MockWithVerifyRuntime is a mock of WithVerifyRuntime interface.
type MockWithVerifyRuntime struct {
	ctrl     *gomock.Controller
	recorder *MockWithVerifyRuntimeMockRecorder
	isgomock struct{}
}

// MockWithVerifyRuntimeMockRecorder is the mock recorder for MockWithVerifyRuntime.
type MockWithVerifyRuntimeMockRecorder struct {
	mock *MockWithVerifyRuntime
}

// NewMockWithVerifyRuntime creates a new mock instance.
func NewMockWithVerifyRuntime(ctrl *gomock.Controller) *MockWithVerifyRuntime {
	mock := &MockWithVerifyRuntime{ctrl: ctrl}
	mock.recorder = &MockWithVerifyRuntimeMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockChainVMWithNetwork is a mock of ChainVMWithNetwork interface.
type MockChainVMWithNetwork struct {
	ctrl     *gomock.Controller
	recorder *MockChainVMWithNetworkMockRecorder
	isgomock struct{}
}

// MockChainVMWithNetworkMockRecorder is the mock recorder for MockChainVMWithNetwork.
type MockChainVMWithNetworkMockRecorder struct {
	mock *MockChainVMWithNetwork
}

// NewMockChainVMWithNetwork creates a new mock instance.
func NewMockChainVMWithNetwork(ctrl *gomock.Controller) *MockChainVMWithNetwork {
	mock := &MockChainVMWithNetwork{ctrl: ctrl}
	mock.recorder = &MockChainVMWithNetworkMockRecorder{mock}
	return mock
}

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

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

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

// Connected mocks base method.
func (m *MockChainVMWithNetwork) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockChainVMWithNetworkMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockChainVMWithNetwork)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockChainVMWithNetwork) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockChainVMWithNetwork) 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 *MockChainVMWithNetworkMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockChainVMWithNetwork)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockChainVMWithNetwork) 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 *MockChainVMWithNetworkMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockChainVMWithNetwork)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockChainVMWithNetwork) 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 *MockChainVMWithNetworkMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockChainVMWithNetwork)(nil).Version), arg0)
}

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

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

// MockChainVMWithHealth is a mock of ChainVMWithHealth interface.
type MockChainVMWithHealth struct {
	ctrl     *gomock.Controller
	recorder *MockChainVMWithHealthMockRecorder
	isgomock struct{}
}

// MockChainVMWithHealthMockRecorder is the mock recorder for MockChainVMWithHealth.
type MockChainVMWithHealthMockRecorder struct {
	mock *MockChainVMWithHealth
}

// NewMockChainVMWithHealth creates a new mock instance.
func NewMockChainVMWithHealth(ctrl *gomock.Controller) *MockChainVMWithHealth {
	mock := &MockChainVMWithHealth{ctrl: ctrl}
	mock.recorder = &MockChainVMWithHealthMockRecorder{mock}
	return mock
}

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

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

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

// Connected mocks base method.
func (m *MockChainVMWithHealth) Connected(arg0 context.Context, arg1 ids.NodeID, arg2 *chain.VersionInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connected", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connected indicates an expected call of Connected.
func (mr *MockChainVMWithHealthMockRecorder) Connected(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockChainVMWithHealth)(nil).Connected), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// Initialize mocks base method.
func (m *MockChainVMWithHealth) Initialize(ctx context.Context, init vm.Init) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", ctx, init)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// LastAccepted mocks base method.
func (m *MockChainVMWithHealth) 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 *MockChainVMWithHealthMockRecorder) LastAccepted(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastAccepted", reflect.TypeOf((*MockChainVMWithHealth)(nil).LastAccepted), arg0)
}

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

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

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

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

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

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

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

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

// Shutdown mocks base method.
func (m *MockChainVMWithHealth) 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 *MockChainVMWithHealthMockRecorder) Shutdown(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockChainVMWithHealth)(nil).Shutdown), arg0)
}

// Version mocks base method.
func (m *MockChainVMWithHealth) 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 *MockChainVMWithHealthMockRecorder) Version(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockChainVMWithHealth)(nil).Version), arg0)
}

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

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