// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/dot/state (interfaces: BlockState)
//
// Generated by this command:
//
//	mockgen -destination=mock_block_state_test.go -package babe github.com/ChainSafe/gossamer/dot/state BlockState
//

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

import (
	reflect "reflect"
	time "time"

	state "github.com/ChainSafe/gossamer/dot/state"
	types "github.com/ChainSafe/gossamer/dot/types"
	hash "github.com/ChainSafe/gossamer/internal/primitives/core/hash"
	runtime "github.com/ChainSafe/gossamer/internal/primitives/runtime"
	overlayedchanges "github.com/ChainSafe/gossamer/internal/primitives/state-machine/overlayedchanges"
	storage "github.com/ChainSafe/gossamer/internal/primitives/storage"
	blocktree "github.com/ChainSafe/gossamer/lib/blocktree"
	common "github.com/ChainSafe/gossamer/lib/common"
	runtime0 "github.com/ChainSafe/gossamer/lib/runtime"
	storage0 "github.com/ChainSafe/gossamer/lib/runtime/storage"
	gomock "go.uber.org/mock/gomock"
)

// MockBlockState is a mock of BlockState interface.
type MockBlockState struct {
	ctrl     *gomock.Controller
	recorder *MockBlockStateMockRecorder
	isgomock struct{}
}

// MockBlockStateMockRecorder is the mock recorder for MockBlockState.
type MockBlockStateMockRecorder struct {
	mock *MockBlockState
}

// NewMockBlockState creates a new mock instance.
func NewMockBlockState(ctrl *gomock.Controller) *MockBlockState {
	mock := &MockBlockState{ctrl: ctrl}
	mock.recorder = &MockBlockStateMockRecorder{mock}
	return mock
}

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

// AddBlock mocks base method.
func (m *MockBlockState) AddBlock(arg0 *types.Block, arg1 *overlayedchanges.OverlayedChanges[hash.H256, runtime.BlakeTwo256], arg2 *storage.StateVersion) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBlock", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// AddBlockWithArrivalTime mocks base method.
func (m *MockBlockState) AddBlockWithArrivalTime(block *types.Block, arrivalTime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBlockWithArrivalTime", block, arrivalTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddBlockWithArrivalTime indicates an expected call of AddBlockWithArrivalTime.
func (mr *MockBlockStateMockRecorder) AddBlockWithArrivalTime(block, arrivalTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlockWithArrivalTime", reflect.TypeOf((*MockBlockState)(nil).AddBlockWithArrivalTime), block, arrivalTime)
}

// BestBlock mocks base method.
func (m *MockBlockState) BestBlock() (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BestBlock")
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BestBlockHash mocks base method.
func (m *MockBlockState) BestBlockHash() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BestBlockHash")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

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

// BestBlockHeader mocks base method.
func (m *MockBlockState) BestBlockHeader() (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BestBlockHeader")
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BestBlockNumber mocks base method.
func (m *MockBlockState) BestBlockNumber() (uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BestBlockNumber")
	ret0, _ := ret[0].(uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CompareAndSetBlockData mocks base method.
func (m *MockBlockState) CompareAndSetBlockData(bd *types.BlockData) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareAndSetBlockData", bd)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompareAndSetBlockData indicates an expected call of CompareAndSetBlockData.
func (mr *MockBlockStateMockRecorder) CompareAndSetBlockData(bd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareAndSetBlockData", reflect.TypeOf((*MockBlockState)(nil).CompareAndSetBlockData), bd)
}

// FreeFinalisedNotifierChannel mocks base method.
func (m *MockBlockState) FreeFinalisedNotifierChannel(ch chan *types.FinalisationInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FreeFinalisedNotifierChannel", ch)
}

// FreeFinalisedNotifierChannel indicates an expected call of FreeFinalisedNotifierChannel.
func (mr *MockBlockStateMockRecorder) FreeFinalisedNotifierChannel(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeFinalisedNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeFinalisedNotifierChannel), ch)
}

// FreeImportedBlockNotifierChannel mocks base method.
func (m *MockBlockState) FreeImportedBlockNotifierChannel(ch chan *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FreeImportedBlockNotifierChannel", ch)
}

// FreeImportedBlockNotifierChannel indicates an expected call of FreeImportedBlockNotifierChannel.
func (mr *MockBlockStateMockRecorder) FreeImportedBlockNotifierChannel(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeImportedBlockNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeImportedBlockNotifierChannel), ch)
}

// GenesisHash mocks base method.
func (m *MockBlockState) GenesisHash() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenesisHash")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

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

// GetAllBlocksAtNumber mocks base method.
func (m *MockBlockState) GetAllBlocksAtNumber(num uint) ([]common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllBlocksAtNumber", num)
	ret0, _ := ret[0].([]common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllBlocksAtNumber indicates an expected call of GetAllBlocksAtNumber.
func (mr *MockBlockStateMockRecorder) GetAllBlocksAtNumber(num any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBlocksAtNumber", reflect.TypeOf((*MockBlockState)(nil).GetAllBlocksAtNumber), num)
}

// GetBlockBody mocks base method.
func (m *MockBlockState) GetBlockBody(arg0 common.Hash) (*types.Body, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockBody", arg0)
	ret0, _ := ret[0].(*types.Body)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlockByHash mocks base method.
func (m *MockBlockState) GetBlockByHash(arg0 common.Hash) (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockByHash", arg0)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlockByNumber mocks base method.
func (m *MockBlockState) GetBlockByNumber(blockNumber uint) (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockByNumber", blockNumber)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockByNumber indicates an expected call of GetBlockByNumber.
func (mr *MockBlockStateMockRecorder) GetBlockByNumber(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByNumber", reflect.TypeOf((*MockBlockState)(nil).GetBlockByNumber), blockNumber)
}

// GetBlockHashesBySlot mocks base method.
func (m *MockBlockState) GetBlockHashesBySlot(slotNum uint64) ([]common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockHashesBySlot", slotNum)
	ret0, _ := ret[0].([]common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockHashesBySlot indicates an expected call of GetBlockHashesBySlot.
func (mr *MockBlockStateMockRecorder) GetBlockHashesBySlot(slotNum any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockHashesBySlot", reflect.TypeOf((*MockBlockState)(nil).GetBlockHashesBySlot), slotNum)
}

// GetBlockStateRoot mocks base method.
func (m *MockBlockState) GetBlockStateRoot(bhash common.Hash) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockStateRoot", bhash)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockStateRoot indicates an expected call of GetBlockStateRoot.
func (mr *MockBlockStateMockRecorder) GetBlockStateRoot(bhash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockStateRoot", reflect.TypeOf((*MockBlockState)(nil).GetBlockStateRoot), bhash)
}

// GetFinalisedHeader mocks base method.
func (m *MockBlockState) GetFinalisedHeader(round, setID uint64) (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFinalisedHeader", round, setID)
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFinalisedHeader indicates an expected call of GetFinalisedHeader.
func (mr *MockBlockStateMockRecorder) GetFinalisedHeader(round, setID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedHeader", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedHeader), round, setID)
}

// GetFinalisedNotifierChannel mocks base method.
func (m *MockBlockState) GetFinalisedNotifierChannel() chan *types.FinalisationInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFinalisedNotifierChannel")
	ret0, _ := ret[0].(chan *types.FinalisationInfo)
	return ret0
}

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

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

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

// GetHashByNumber mocks base method.
func (m *MockBlockState) GetHashByNumber(blockNumber uint) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHashByNumber", blockNumber)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHashByNumber indicates an expected call of GetHashByNumber.
func (mr *MockBlockStateMockRecorder) GetHashByNumber(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHashByNumber", reflect.TypeOf((*MockBlockState)(nil).GetHashByNumber), blockNumber)
}

// GetHashesByNumber mocks base method.
func (m *MockBlockState) GetHashesByNumber(blockNumber uint) ([]common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHashesByNumber", blockNumber)
	ret0, _ := ret[0].([]common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHashesByNumber indicates an expected call of GetHashesByNumber.
func (mr *MockBlockStateMockRecorder) GetHashesByNumber(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHashesByNumber", reflect.TypeOf((*MockBlockState)(nil).GetHashesByNumber), blockNumber)
}

// GetHeader mocks base method.
func (m *MockBlockState) GetHeader(bhash common.Hash) (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader", bhash)
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHeader indicates an expected call of GetHeader.
func (mr *MockBlockStateMockRecorder) GetHeader(bhash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeader", reflect.TypeOf((*MockBlockState)(nil).GetHeader), bhash)
}

// GetHeaderByNumber mocks base method.
func (m *MockBlockState) GetHeaderByNumber(num uint) (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByNumber", num)
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHeaderByNumber indicates an expected call of GetHeaderByNumber.
func (mr *MockBlockStateMockRecorder) GetHeaderByNumber(num any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByNumber", reflect.TypeOf((*MockBlockState)(nil).GetHeaderByNumber), num)
}

// GetHighestFinalisedHash mocks base method.
func (m *MockBlockState) GetHighestFinalisedHash() (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHighestFinalisedHash")
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHighestFinalisedHeader mocks base method.
func (m *MockBlockState) GetHighestFinalisedHeader() (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHighestFinalisedHeader")
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHighestRoundAndSetID mocks base method.
func (m *MockBlockState) GetHighestRoundAndSetID() (uint64, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHighestRoundAndSetID")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetImportedBlockNotifierChannel mocks base method.
func (m *MockBlockState) GetImportedBlockNotifierChannel() chan *types.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImportedBlockNotifierChannel")
	ret0, _ := ret[0].(chan *types.Block)
	return ret0
}

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

// GetJustification mocks base method.
func (m *MockBlockState) GetJustification(arg0 common.Hash) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJustification", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLastFinalized mocks base method.
func (m *MockBlockState) GetLastFinalized() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastFinalized")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

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

// GetMessageQueue mocks base method.
func (m *MockBlockState) GetMessageQueue(arg0 common.Hash) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMessageQueue", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNonFinalisedBlocks mocks base method.
func (m *MockBlockState) GetNonFinalisedBlocks() []common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNonFinalisedBlocks")
	ret0, _ := ret[0].([]common.Hash)
	return ret0
}

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

// GetReceipt mocks base method.
func (m *MockBlockState) GetReceipt(arg0 common.Hash) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReceipt", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetRuntime mocks base method.
func (m *MockBlockState) GetRuntime(blockHash common.Hash) (runtime0.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRuntime", blockHash)
	ret0, _ := ret[0].(runtime0.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRuntime indicates an expected call of GetRuntime.
func (mr *MockBlockStateMockRecorder) GetRuntime(blockHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRuntime", reflect.TypeOf((*MockBlockState)(nil).GetRuntime), blockHash)
}

// GetSlotForBlock mocks base method.
func (m *MockBlockState) GetSlotForBlock(arg0 common.Hash) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSlotForBlock", arg0)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTries mocks base method.
func (m *MockBlockState) GetTries() *state.Tries {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTries")
	ret0, _ := ret[0].(*state.Tries)
	return ret0
}

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

// HandleRuntimeChanges mocks base method.
func (m *MockBlockState) HandleRuntimeChanges(newState storage0.TrieState, in runtime0.Instance, bHash common.Hash) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleRuntimeChanges", newState, in, bHash)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleRuntimeChanges indicates an expected call of HandleRuntimeChanges.
func (mr *MockBlockStateMockRecorder) HandleRuntimeChanges(newState, in, bHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRuntimeChanges", reflect.TypeOf((*MockBlockState)(nil).HandleRuntimeChanges), newState, in, bHash)
}

// HasFinalisedBlock mocks base method.
func (m *MockBlockState) HasFinalisedBlock(round, setID uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasFinalisedBlock", round, setID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasFinalisedBlock indicates an expected call of HasFinalisedBlock.
func (mr *MockBlockStateMockRecorder) HasFinalisedBlock(round, setID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasFinalisedBlock", reflect.TypeOf((*MockBlockState)(nil).HasFinalisedBlock), round, setID)
}

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

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

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

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

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

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

// IsDescendantOf mocks base method.
func (m *MockBlockState) IsDescendantOf(parent, child common.Hash) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDescendantOf", parent, child)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsDescendantOf indicates an expected call of IsDescendantOf.
func (mr *MockBlockStateMockRecorder) IsDescendantOf(parent, child any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDescendantOf", reflect.TypeOf((*MockBlockState)(nil).IsDescendantOf), parent, child)
}

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

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

// Leaves mocks base method.
func (m *MockBlockState) Leaves() []common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Leaves")
	ret0, _ := ret[0].([]common.Hash)
	return ret0
}

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

// LowestCommonAncestor mocks base method.
func (m *MockBlockState) LowestCommonAncestor(a, b common.Hash) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LowestCommonAncestor", a, b)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LowestCommonAncestor indicates an expected call of LowestCommonAncestor.
func (mr *MockBlockStateMockRecorder) LowestCommonAncestor(a, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LowestCommonAncestor", reflect.TypeOf((*MockBlockState)(nil).LowestCommonAncestor), a, b)
}

// NumberIsFinalised mocks base method.
func (m *MockBlockState) NumberIsFinalised(blockNumber uint) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NumberIsFinalised", blockNumber)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NumberIsFinalised indicates an expected call of NumberIsFinalised.
func (mr *MockBlockStateMockRecorder) NumberIsFinalised(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumberIsFinalised", reflect.TypeOf((*MockBlockState)(nil).NumberIsFinalised), blockNumber)
}

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

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

// Range mocks base method.
func (m *MockBlockState) Range(startHash, endHash common.Hash) ([]common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Range", startHash, endHash)
	ret0, _ := ret[0].([]common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Range indicates an expected call of Range.
func (mr *MockBlockStateMockRecorder) Range(startHash, endHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Range", reflect.TypeOf((*MockBlockState)(nil).Range), startHash, endHash)
}

// RangeInMemory mocks base method.
func (m *MockBlockState) RangeInMemory(start, end common.Hash) ([]common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeInMemory", start, end)
	ret0, _ := ret[0].([]common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeInMemory indicates an expected call of RangeInMemory.
func (mr *MockBlockStateMockRecorder) RangeInMemory(start, end any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeInMemory", reflect.TypeOf((*MockBlockState)(nil).RangeInMemory), start, end)
}

// RegisterRuntimeUpdatedChannel mocks base method.
func (m *MockBlockState) RegisterRuntimeUpdatedChannel(ch chan<- runtime0.Version) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterRuntimeUpdatedChannel", ch)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterRuntimeUpdatedChannel indicates an expected call of RegisterRuntimeUpdatedChannel.
func (mr *MockBlockStateMockRecorder) RegisterRuntimeUpdatedChannel(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRuntimeUpdatedChannel", reflect.TypeOf((*MockBlockState)(nil).RegisterRuntimeUpdatedChannel), ch)
}

// Rewind mocks base method.
func (m *MockBlockState) Rewind(toBlock uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rewind", toBlock)
	ret0, _ := ret[0].(error)
	return ret0
}

// Rewind indicates an expected call of Rewind.
func (mr *MockBlockStateMockRecorder) Rewind(toBlock any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rewind", reflect.TypeOf((*MockBlockState)(nil).Rewind), toBlock)
}

// SetBlockTree mocks base method.
func (m *MockBlockState) SetBlockTree(arg0 *blocktree.BlockTree) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBlockTree", arg0)
}

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

// SetFinalisedHash mocks base method.
func (m *MockBlockState) SetFinalisedHash(arg0 common.Hash, round, setID uint64, finalizeAncestors bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFinalisedHash", arg0, round, setID, finalizeAncestors)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetFinalisedHash indicates an expected call of SetFinalisedHash.
func (mr *MockBlockStateMockRecorder) SetFinalisedHash(arg0, round, setID, finalizeAncestors any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinalisedHash", reflect.TypeOf((*MockBlockState)(nil).SetFinalisedHash), arg0, round, setID, finalizeAncestors)
}

// SetFinalizedHeader mocks base method.
func (m *MockBlockState) SetFinalizedHeader(header *types.Header) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFinalizedHeader", header)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetFinalizedHeader indicates an expected call of SetFinalizedHeader.
func (mr *MockBlockStateMockRecorder) SetFinalizedHeader(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinalizedHeader", reflect.TypeOf((*MockBlockState)(nil).SetFinalizedHeader), header)
}

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

// SetFirstNonOriginSlotNumber indicates an expected call of SetFirstNonOriginSlotNumber.
func (mr *MockBlockStateMockRecorder) SetFirstNonOriginSlotNumber(slotNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFirstNonOriginSlotNumber", reflect.TypeOf((*MockBlockState)(nil).SetFirstNonOriginSlotNumber), slotNumber)
}

// SetHeader mocks base method.
func (m *MockBlockState) SetHeader(header *types.Header) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", header)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockBlockStateMockRecorder) SetHeader(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBlockState)(nil).SetHeader), header)
}

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

// SetHighestRoundAndSetID indicates an expected call of SetHighestRoundAndSetID.
func (mr *MockBlockStateMockRecorder) SetHighestRoundAndSetID(round, setID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHighestRoundAndSetID", reflect.TypeOf((*MockBlockState)(nil).SetHighestRoundAndSetID), round, setID)
}

// SetJustification mocks base method.
func (m *MockBlockState) SetJustification(arg0 common.Hash, data []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetJustification", arg0, data)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StoreRuntime mocks base method.
func (m *MockBlockState) StoreRuntime(blockHash common.Hash, arg1 runtime0.Instance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StoreRuntime", blockHash, arg1)
}

// StoreRuntime indicates an expected call of StoreRuntime.
func (mr *MockBlockStateMockRecorder) StoreRuntime(blockHash, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreRuntime", reflect.TypeOf((*MockBlockState)(nil).StoreRuntime), blockHash, arg1)
}

// UnregisterRuntimeUpdatedChannel mocks base method.
func (m *MockBlockState) UnregisterRuntimeUpdatedChannel(id uint32) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterRuntimeUpdatedChannel", id)
	ret0, _ := ret[0].(bool)
	return ret0
}

// UnregisterRuntimeUpdatedChannel indicates an expected call of UnregisterRuntimeUpdatedChannel.
func (mr *MockBlockStateMockRecorder) UnregisterRuntimeUpdatedChannel(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterRuntimeUpdatedChannel", reflect.TypeOf((*MockBlockState)(nil).UnregisterRuntimeUpdatedChannel), id)
}
