// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/dot/rpc/modules (interfaces: StorageAPI,BlockAPI,NetworkAPI,BlockProducerAPI,TransactionStateAPI,CoreAPI,SystemAPI,BlockFinalityAPI,RuntimeStorageAPI,SyncStateAPI)
//
// Generated by this command:
//
//	mockgen -destination=mocks/mocks.go -package mocks . StorageAPI,BlockAPI,NetworkAPI,BlockProducerAPI,TransactionStateAPI,CoreAPI,SystemAPI,BlockFinalityAPI,RuntimeStorageAPI,SyncStateAPI
//

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

import (
	reflect "reflect"

	core "github.com/ChainSafe/gossamer/dot/core"
	state "github.com/ChainSafe/gossamer/dot/state"
	types "github.com/ChainSafe/gossamer/dot/types"
	common "github.com/ChainSafe/gossamer/lib/common"
	ed25519 "github.com/ChainSafe/gossamer/lib/crypto/ed25519"
	genesis "github.com/ChainSafe/gossamer/lib/genesis"
	grandpa "github.com/ChainSafe/gossamer/lib/grandpa"
	runtime "github.com/ChainSafe/gossamer/lib/runtime"
	transaction "github.com/ChainSafe/gossamer/lib/transaction"
	trie "github.com/ChainSafe/gossamer/pkg/trie"
	gomock "go.uber.org/mock/gomock"
)

// MockStorageAPI is a mock of StorageAPI interface.
type MockStorageAPI struct {
	ctrl     *gomock.Controller
	recorder *MockStorageAPIMockRecorder
	isgomock struct{}
}

// MockStorageAPIMockRecorder is the mock recorder for MockStorageAPI.
type MockStorageAPIMockRecorder struct {
	mock *MockStorageAPI
}

// NewMockStorageAPI creates a new mock instance.
func NewMockStorageAPI(ctrl *gomock.Controller) *MockStorageAPI {
	mock := &MockStorageAPI{ctrl: ctrl}
	mock.recorder = &MockStorageAPIMockRecorder{mock}
	return mock
}

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

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

// Entries indicates an expected call of Entries.
func (mr *MockStorageAPIMockRecorder) Entries(root any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Entries", reflect.TypeOf((*MockStorageAPI)(nil).Entries), root)
}

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

// GetKeysWithPrefix indicates an expected call of GetKeysWithPrefix.
func (mr *MockStorageAPIMockRecorder) GetKeysWithPrefix(root, prefix any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeysWithPrefix", reflect.TypeOf((*MockStorageAPI)(nil).GetKeysWithPrefix), root, prefix)
}

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

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

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

// GetStorage indicates an expected call of GetStorage.
func (mr *MockStorageAPIMockRecorder) GetStorage(root, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorage", reflect.TypeOf((*MockStorageAPI)(nil).GetStorage), root, key)
}

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

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

// GetStorageChild mocks base method.
func (m *MockStorageAPI) GetStorageChild(root *common.Hash, keyToChild []byte) (trie.Trie, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageChild", root, keyToChild)
	ret0, _ := ret[0].(trie.Trie)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageChild indicates an expected call of GetStorageChild.
func (mr *MockStorageAPIMockRecorder) GetStorageChild(root, keyToChild any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageChild", reflect.TypeOf((*MockStorageAPI)(nil).GetStorageChild), root, keyToChild)
}

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

// GetStorageFromChild indicates an expected call of GetStorageFromChild.
func (mr *MockStorageAPIMockRecorder) GetStorageFromChild(root, keyToChild, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageFromChild", reflect.TypeOf((*MockStorageAPI)(nil).GetStorageFromChild), root, keyToChild, key)
}

// RegisterStorageObserver mocks base method.
func (m *MockStorageAPI) RegisterStorageObserver(observer state.Observer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterStorageObserver", observer)
}

// RegisterStorageObserver indicates an expected call of RegisterStorageObserver.
func (mr *MockStorageAPIMockRecorder) RegisterStorageObserver(observer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStorageObserver", reflect.TypeOf((*MockStorageAPI)(nil).RegisterStorageObserver), observer)
}

// UnregisterStorageObserver mocks base method.
func (m *MockStorageAPI) UnregisterStorageObserver(observer state.Observer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnregisterStorageObserver", observer)
}

// UnregisterStorageObserver indicates an expected call of UnregisterStorageObserver.
func (mr *MockStorageAPIMockRecorder) UnregisterStorageObserver(observer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterStorageObserver", reflect.TypeOf((*MockStorageAPI)(nil).UnregisterStorageObserver), observer)
}

// MockBlockAPI is a mock of BlockAPI interface.
type MockBlockAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBlockAPIMockRecorder
	isgomock struct{}
}

// MockBlockAPIMockRecorder is the mock recorder for MockBlockAPI.
type MockBlockAPIMockRecorder struct {
	mock *MockBlockAPI
}

// NewMockBlockAPI creates a new mock instance.
func NewMockBlockAPI(ctrl *gomock.Controller) *MockBlockAPI {
	mock := &MockBlockAPI{ctrl: ctrl}
	mock.recorder = &MockBlockAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RangeInMemory mocks base method.
func (m *MockBlockAPI) 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 *MockBlockAPIMockRecorder) RangeInMemory(start, end any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeInMemory", reflect.TypeOf((*MockBlockAPI)(nil).RangeInMemory), start, end)
}

// RegisterRuntimeUpdatedChannel mocks base method.
func (m *MockBlockAPI) RegisterRuntimeUpdatedChannel(ch chan<- runtime.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 *MockBlockAPIMockRecorder) RegisterRuntimeUpdatedChannel(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRuntimeUpdatedChannel", reflect.TypeOf((*MockBlockAPI)(nil).RegisterRuntimeUpdatedChannel), ch)
}

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

// MockNetworkAPI is a mock of NetworkAPI interface.
type MockNetworkAPI struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkAPIMockRecorder
	isgomock struct{}
}

// MockNetworkAPIMockRecorder is the mock recorder for MockNetworkAPI.
type MockNetworkAPIMockRecorder struct {
	mock *MockNetworkAPI
}

// NewMockNetworkAPI creates a new mock instance.
func NewMockNetworkAPI(ctrl *gomock.Controller) *MockNetworkAPI {
	mock := &MockNetworkAPI{ctrl: ctrl}
	mock.recorder = &MockNetworkAPIMockRecorder{mock}
	return mock
}

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

// AddReservedPeers mocks base method.
func (m *MockNetworkAPI) AddReservedPeers(addrs ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range addrs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddReservedPeers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddReservedPeers indicates an expected call of AddReservedPeers.
func (mr *MockNetworkAPIMockRecorder) AddReservedPeers(addrs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReservedPeers", reflect.TypeOf((*MockNetworkAPI)(nil).AddReservedPeers), addrs...)
}

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

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

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

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

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

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

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

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

// RemoveReservedPeers mocks base method.
func (m *MockNetworkAPI) RemoveReservedPeers(addrs ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range addrs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveReservedPeers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveReservedPeers indicates an expected call of RemoveReservedPeers.
func (mr *MockNetworkAPIMockRecorder) RemoveReservedPeers(addrs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveReservedPeers", reflect.TypeOf((*MockNetworkAPI)(nil).RemoveReservedPeers), addrs...)
}

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

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

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

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

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

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

// MockBlockProducerAPI is a mock of BlockProducerAPI interface.
type MockBlockProducerAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBlockProducerAPIMockRecorder
	isgomock struct{}
}

// MockBlockProducerAPIMockRecorder is the mock recorder for MockBlockProducerAPI.
type MockBlockProducerAPIMockRecorder struct {
	mock *MockBlockProducerAPI
}

// NewMockBlockProducerAPI creates a new mock instance.
func NewMockBlockProducerAPI(ctrl *gomock.Controller) *MockBlockProducerAPI {
	mock := &MockBlockProducerAPI{ctrl: ctrl}
	mock.recorder = &MockBlockProducerAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// MockTransactionStateAPI is a mock of TransactionStateAPI interface.
type MockTransactionStateAPI struct {
	ctrl     *gomock.Controller
	recorder *MockTransactionStateAPIMockRecorder
	isgomock struct{}
}

// MockTransactionStateAPIMockRecorder is the mock recorder for MockTransactionStateAPI.
type MockTransactionStateAPIMockRecorder struct {
	mock *MockTransactionStateAPI
}

// NewMockTransactionStateAPI creates a new mock instance.
func NewMockTransactionStateAPI(ctrl *gomock.Controller) *MockTransactionStateAPI {
	mock := &MockTransactionStateAPI{ctrl: ctrl}
	mock.recorder = &MockTransactionStateAPIMockRecorder{mock}
	return mock
}

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

// Pending mocks base method.
func (m *MockTransactionStateAPI) Pending() []*transaction.ValidTransaction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pending")
	ret0, _ := ret[0].([]*transaction.ValidTransaction)
	return ret0
}

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

// MockCoreAPI is a mock of CoreAPI interface.
type MockCoreAPI struct {
	ctrl     *gomock.Controller
	recorder *MockCoreAPIMockRecorder
	isgomock struct{}
}

// MockCoreAPIMockRecorder is the mock recorder for MockCoreAPI.
type MockCoreAPIMockRecorder struct {
	mock *MockCoreAPI
}

// NewMockCoreAPI creates a new mock instance.
func NewMockCoreAPI(ctrl *gomock.Controller) *MockCoreAPI {
	mock := &MockCoreAPI{ctrl: ctrl}
	mock.recorder = &MockCoreAPIMockRecorder{mock}
	return mock
}

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

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

// DecodeSessionKeys indicates an expected call of DecodeSessionKeys.
func (mr *MockCoreAPIMockRecorder) DecodeSessionKeys(enc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeSessionKeys", reflect.TypeOf((*MockCoreAPI)(nil).DecodeSessionKeys), enc)
}

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

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

// GetReadProofAt mocks base method.
func (m *MockCoreAPI) GetReadProofAt(block common.Hash, keys [][]byte) (common.Hash, [][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReadProofAt", block, keys)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].([][]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetReadProofAt indicates an expected call of GetReadProofAt.
func (mr *MockCoreAPIMockRecorder) GetReadProofAt(block, keys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReadProofAt", reflect.TypeOf((*MockCoreAPI)(nil).GetReadProofAt), block, keys)
}

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

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

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

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

// HasKey mocks base method.
func (m *MockCoreAPI) HasKey(pubKeyStr, keyType string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasKey", pubKeyStr, keyType)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasKey indicates an expected call of HasKey.
func (mr *MockCoreAPIMockRecorder) HasKey(pubKeyStr, keyType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasKey", reflect.TypeOf((*MockCoreAPI)(nil).HasKey), pubKeyStr, keyType)
}

// InsertKey mocks base method.
func (m *MockCoreAPI) InsertKey(kp core.KeyPair, keystoreType string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertKey", kp, keystoreType)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertKey indicates an expected call of InsertKey.
func (mr *MockCoreAPIMockRecorder) InsertKey(kp, keystoreType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertKey", reflect.TypeOf((*MockCoreAPI)(nil).InsertKey), kp, keystoreType)
}

// MockSystemAPI is a mock of SystemAPI interface.
type MockSystemAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSystemAPIMockRecorder
	isgomock struct{}
}

// MockSystemAPIMockRecorder is the mock recorder for MockSystemAPI.
type MockSystemAPIMockRecorder struct {
	mock *MockSystemAPI
}

// NewMockSystemAPI creates a new mock instance.
func NewMockSystemAPI(ctrl *gomock.Controller) *MockSystemAPI {
	mock := &MockSystemAPI{ctrl: ctrl}
	mock.recorder = &MockSystemAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockBlockFinalityAPI is a mock of BlockFinalityAPI interface.
type MockBlockFinalityAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBlockFinalityAPIMockRecorder
	isgomock struct{}
}

// MockBlockFinalityAPIMockRecorder is the mock recorder for MockBlockFinalityAPI.
type MockBlockFinalityAPIMockRecorder struct {
	mock *MockBlockFinalityAPI
}

// NewMockBlockFinalityAPI creates a new mock instance.
func NewMockBlockFinalityAPI(ctrl *gomock.Controller) *MockBlockFinalityAPI {
	mock := &MockBlockFinalityAPI{ctrl: ctrl}
	mock.recorder = &MockBlockFinalityAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

// GetVoters mocks base method.
func (m *MockBlockFinalityAPI) GetVoters() grandpa.Voters {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVoters")
	ret0, _ := ret[0].(grandpa.Voters)
	return ret0
}

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

// PreCommits mocks base method.
func (m *MockBlockFinalityAPI) PreCommits() []ed25519.PublicKeyBytes {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreCommits")
	ret0, _ := ret[0].([]ed25519.PublicKeyBytes)
	return ret0
}

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

// PreVotes mocks base method.
func (m *MockBlockFinalityAPI) PreVotes() []ed25519.PublicKeyBytes {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreVotes")
	ret0, _ := ret[0].([]ed25519.PublicKeyBytes)
	return ret0
}

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

// MockRuntimeStorageAPI is a mock of RuntimeStorageAPI interface.
type MockRuntimeStorageAPI struct {
	ctrl     *gomock.Controller
	recorder *MockRuntimeStorageAPIMockRecorder
	isgomock struct{}
}

// MockRuntimeStorageAPIMockRecorder is the mock recorder for MockRuntimeStorageAPI.
type MockRuntimeStorageAPIMockRecorder struct {
	mock *MockRuntimeStorageAPI
}

// NewMockRuntimeStorageAPI creates a new mock instance.
func NewMockRuntimeStorageAPI(ctrl *gomock.Controller) *MockRuntimeStorageAPI {
	mock := &MockRuntimeStorageAPI{ctrl: ctrl}
	mock.recorder = &MockRuntimeStorageAPIMockRecorder{mock}
	return mock
}

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

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

// GetLocal indicates an expected call of GetLocal.
func (mr *MockRuntimeStorageAPIMockRecorder) GetLocal(k any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocal", reflect.TypeOf((*MockRuntimeStorageAPI)(nil).GetLocal), k)
}

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

// GetPersistent indicates an expected call of GetPersistent.
func (mr *MockRuntimeStorageAPIMockRecorder) GetPersistent(k any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistent", reflect.TypeOf((*MockRuntimeStorageAPI)(nil).GetPersistent), k)
}

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

// SetLocal indicates an expected call of SetLocal.
func (mr *MockRuntimeStorageAPIMockRecorder) SetLocal(k, v any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLocal", reflect.TypeOf((*MockRuntimeStorageAPI)(nil).SetLocal), k, v)
}

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

// SetPersistent indicates an expected call of SetPersistent.
func (mr *MockRuntimeStorageAPIMockRecorder) SetPersistent(k, v any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistent", reflect.TypeOf((*MockRuntimeStorageAPI)(nil).SetPersistent), k, v)
}

// MockSyncStateAPI is a mock of SyncStateAPI interface.
type MockSyncStateAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSyncStateAPIMockRecorder
	isgomock struct{}
}

// MockSyncStateAPIMockRecorder is the mock recorder for MockSyncStateAPI.
type MockSyncStateAPIMockRecorder struct {
	mock *MockSyncStateAPI
}

// NewMockSyncStateAPI creates a new mock instance.
func NewMockSyncStateAPI(ctrl *gomock.Controller) *MockSyncStateAPI {
	mock := &MockSyncStateAPI{ctrl: ctrl}
	mock.recorder = &MockSyncStateAPIMockRecorder{mock}
	return mock
}

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

// GenSyncSpec mocks base method.
func (m *MockSyncStateAPI) GenSyncSpec(raw bool) (*genesis.Genesis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenSyncSpec", raw)
	ret0, _ := ret[0].(*genesis.Genesis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenSyncSpec indicates an expected call of GenSyncSpec.
func (mr *MockSyncStateAPIMockRecorder) GenSyncSpec(raw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenSyncSpec", reflect.TypeOf((*MockSyncStateAPI)(nil).GenSyncSpec), raw)
}
