// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/OffchainLabs/prysm/v6/validator/client/iface (interfaces: Validator)
//
// Generated by this command:
//
//	mockgen -package=validator_mock -destination=testing/validator-mock/validator_mock.go github.com/OffchainLabs/prysm/v6/validator/client/iface Validator
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	event "github.com/OffchainLabs/prysm/v6/api/client/event"
	proposer "github.com/OffchainLabs/prysm/v6/config/proposer"
	primitives "github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
	iface "github.com/OffchainLabs/prysm/v6/validator/client/iface"
	keymanager "github.com/OffchainLabs/prysm/v6/validator/keymanager"
	gomock "go.uber.org/mock/gomock"
)

// MockValidator is a mock of Validator interface.
type MockValidator struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorMockRecorder
}

// MockValidatorMockRecorder is the mock recorder for MockValidator.
type MockValidatorMockRecorder struct {
	mock *MockValidator
}

// NewMockValidator creates a new mock instance.
func NewMockValidator(ctrl *gomock.Controller) *MockValidator {
	mock := &MockValidator{ctrl: ctrl}
	mock.recorder = &MockValidatorMockRecorder{mock}
	return mock
}

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

// AccountsChangedChan mocks base method.
func (m *MockValidator) AccountsChangedChan() <-chan [][48]byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsChangedChan")
	ret0, _ := ret[0].(<-chan [][48]byte)
	return ret0
}

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

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

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

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

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

// Done mocks base method.
func (m *MockValidator) Done() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Done")
}

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

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

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

// EventsChan mocks base method.
func (m *MockValidator) EventsChan() <-chan *event.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventsChan")
	ret0, _ := ret[0].(<-chan *event.Event)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// LogSubmittedAtts mocks base method.
func (m *MockValidator) LogSubmittedAtts(arg0 primitives.Slot) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LogSubmittedAtts", arg0)
}

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

// LogSubmittedSyncCommitteeMessages mocks base method.
func (m *MockValidator) LogSubmittedSyncCommitteeMessages() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LogSubmittedSyncCommitteeMessages")
}

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

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

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

// NextSlot mocks base method.
func (m *MockValidator) NextSlot() <-chan primitives.Slot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NextSlot")
	ret0, _ := ret[0].(<-chan primitives.Slot)
	return ret0
}

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

// ProcessEvent mocks base method.
func (m *MockValidator) ProcessEvent(arg0 context.Context, arg1 *event.Event) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProcessEvent", arg0, arg1)
}

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

// ProposeBlock mocks base method.
func (m *MockValidator) ProposeBlock(arg0 context.Context, arg1 primitives.Slot, arg2 [48]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProposeBlock", arg0, arg1, arg2)
}

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

// ProposerSettings mocks base method.
func (m *MockValidator) ProposerSettings() *proposer.Settings {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProposerSettings")
	ret0, _ := ret[0].(*proposer.Settings)
	return ret0
}

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

// PushProposerSettings mocks base method.
func (m *MockValidator) PushProposerSettings(arg0 context.Context, arg1 primitives.Slot, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushProposerSettings", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// RolesAt mocks base method.
func (m *MockValidator) RolesAt(arg0 context.Context, arg1 primitives.Slot) (map[[48]byte][]iface.ValidatorRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RolesAt", arg0, arg1)
	ret0, _ := ret[0].(map[[48]byte][]iface.ValidatorRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// SetTicker mocks base method.
func (m *MockValidator) SetTicker() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTicker")
}

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

// SignValidatorRegistrationRequest mocks base method.
func (m *MockValidator) SignValidatorRegistrationRequest(arg0 context.Context, arg1 iface.SigningFunc, arg2 *eth.ValidatorRegistrationV1) (*eth.SignedValidatorRegistrationV1, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignValidatorRegistrationRequest", arg0, arg1, arg2)
	ret0, _ := ret[0].(*eth.SignedValidatorRegistrationV1)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// StartEventStream mocks base method.
func (m *MockValidator) StartEventStream(arg0 context.Context, arg1 []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartEventStream", arg0, arg1)
}

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

// SubmitAggregateAndProof mocks base method.
func (m *MockValidator) SubmitAggregateAndProof(arg0 context.Context, arg1 primitives.Slot, arg2 [48]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SubmitAggregateAndProof", arg0, arg1, arg2)
}

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

// SubmitAttestation mocks base method.
func (m *MockValidator) SubmitAttestation(arg0 context.Context, arg1 primitives.Slot, arg2 [48]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SubmitAttestation", arg0, arg1, arg2)
}

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

// SubmitSignedContributionAndProof mocks base method.
func (m *MockValidator) SubmitSignedContributionAndProof(arg0 context.Context, arg1 primitives.Slot, arg2 [48]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SubmitSignedContributionAndProof", arg0, arg1, arg2)
}

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

// SubmitSyncCommitteeMessage mocks base method.
func (m *MockValidator) SubmitSyncCommitteeMessage(arg0 context.Context, arg1 primitives.Slot, arg2 [48]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SubmitSyncCommitteeMessage", arg0, arg1, arg2)
}

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

// UpdateDomainDataCaches mocks base method.
func (m *MockValidator) UpdateDomainDataCaches(arg0 context.Context, arg1 primitives.Slot) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateDomainDataCaches", arg0, arg1)
}

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

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

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

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

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

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

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

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

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

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

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