mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/staking (interfaces: EvtForwarder,EthereumClientConfirmations,EthereumEventSource,TimeService,EthConfirmations,EthOnChainVerifier,Witness)

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

import (
	context "context"
	big "math/big"
	reflect "reflect"
	time "time"

	types "code.vegaprotocol.io/vega/core/types"
	validators "code.vegaprotocol.io/vega/core/validators"
	v1 "code.vegaprotocol.io/vega/protos/vega/commands/v1"
	types0 "github.com/ethereum/go-ethereum/core/types"
	gomock "github.com/golang/mock/gomock"
)

// MockEvtForwarder is a mock of EvtForwarder interface.
type MockEvtForwarder struct {
	ctrl     *gomock.Controller
	recorder *MockEvtForwarderMockRecorder
}

// MockEvtForwarderMockRecorder is the mock recorder for MockEvtForwarder.
type MockEvtForwarderMockRecorder struct {
	mock *MockEvtForwarder
}

// NewMockEvtForwarder creates a new mock instance.
func NewMockEvtForwarder(ctrl *gomock.Controller) *MockEvtForwarder {
	mock := &MockEvtForwarder{ctrl: ctrl}
	mock.recorder = &MockEvtForwarderMockRecorder{mock}
	return mock
}

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

// ForwardFromSelf mocks base method.
func (m *MockEvtForwarder) ForwardFromSelf(arg0 *v1.ChainEvent) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ForwardFromSelf", arg0)
}

// ForwardFromSelf indicates an expected call of ForwardFromSelf.
func (mr *MockEvtForwarderMockRecorder) ForwardFromSelf(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForwardFromSelf", reflect.TypeOf((*MockEvtForwarder)(nil).ForwardFromSelf), arg0)
}

// MockEthereumClientConfirmations is a mock of EthereumClientConfirmations interface.
type MockEthereumClientConfirmations struct {
	ctrl     *gomock.Controller
	recorder *MockEthereumClientConfirmationsMockRecorder
}

// MockEthereumClientConfirmationsMockRecorder is the mock recorder for MockEthereumClientConfirmations.
type MockEthereumClientConfirmationsMockRecorder struct {
	mock *MockEthereumClientConfirmations
}

// NewMockEthereumClientConfirmations creates a new mock instance.
func NewMockEthereumClientConfirmations(ctrl *gomock.Controller) *MockEthereumClientConfirmations {
	mock := &MockEthereumClientConfirmations{ctrl: ctrl}
	mock.recorder = &MockEthereumClientConfirmationsMockRecorder{mock}
	return mock
}

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

// HeaderByNumber mocks base method.
func (m *MockEthereumClientConfirmations) HeaderByNumber(arg0 context.Context, arg1 *big.Int) (*types0.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByNumber", arg0, arg1)
	ret0, _ := ret[0].(*types0.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByNumber indicates an expected call of HeaderByNumber.
func (mr *MockEthereumClientConfirmationsMockRecorder) HeaderByNumber(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockEthereumClientConfirmations)(nil).HeaderByNumber), arg0, arg1)
}

// MockEthereumEventSource is a mock of EthereumEventSource interface.
type MockEthereumEventSource struct {
	ctrl     *gomock.Controller
	recorder *MockEthereumEventSourceMockRecorder
}

// MockEthereumEventSourceMockRecorder is the mock recorder for MockEthereumEventSource.
type MockEthereumEventSourceMockRecorder struct {
	mock *MockEthereumEventSource
}

// NewMockEthereumEventSource creates a new mock instance.
func NewMockEthereumEventSource(ctrl *gomock.Controller) *MockEthereumEventSource {
	mock := &MockEthereumEventSource{ctrl: ctrl}
	mock.recorder = &MockEthereumEventSourceMockRecorder{mock}
	return mock
}

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

// UpdateStakingStartingBlock mocks base method.
func (m *MockEthereumEventSource) UpdateStakingStartingBlock(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateStakingStartingBlock", arg0)
}

// UpdateStakingStartingBlock indicates an expected call of UpdateStakingStartingBlock.
func (mr *MockEthereumEventSourceMockRecorder) UpdateStakingStartingBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStakingStartingBlock", reflect.TypeOf((*MockEthereumEventSource)(nil).UpdateStakingStartingBlock), arg0)
}

// MockTimeService is a mock of TimeService interface.
type MockTimeService struct {
	ctrl     *gomock.Controller
	recorder *MockTimeServiceMockRecorder
}

// MockTimeServiceMockRecorder is the mock recorder for MockTimeService.
type MockTimeServiceMockRecorder struct {
	mock *MockTimeService
}

// NewMockTimeService creates a new mock instance.
func NewMockTimeService(ctrl *gomock.Controller) *MockTimeService {
	mock := &MockTimeService{ctrl: ctrl}
	mock.recorder = &MockTimeServiceMockRecorder{mock}
	return mock
}

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

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

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

// MockEthConfirmations is a mock of EthConfirmations interface.
type MockEthConfirmations struct {
	ctrl     *gomock.Controller
	recorder *MockEthConfirmationsMockRecorder
}

// MockEthConfirmationsMockRecorder is the mock recorder for MockEthConfirmations.
type MockEthConfirmationsMockRecorder struct {
	mock *MockEthConfirmations
}

// NewMockEthConfirmations creates a new mock instance.
func NewMockEthConfirmations(ctrl *gomock.Controller) *MockEthConfirmations {
	mock := &MockEthConfirmations{ctrl: ctrl}
	mock.recorder = &MockEthConfirmationsMockRecorder{mock}
	return mock
}

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

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

// Check indicates an expected call of Check.
func (mr *MockEthConfirmationsMockRecorder) Check(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockEthConfirmations)(nil).Check), arg0)
}

// MockEthOnChainVerifier is a mock of EthOnChainVerifier interface.
type MockEthOnChainVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockEthOnChainVerifierMockRecorder
}

// MockEthOnChainVerifierMockRecorder is the mock recorder for MockEthOnChainVerifier.
type MockEthOnChainVerifierMockRecorder struct {
	mock *MockEthOnChainVerifier
}

// NewMockEthOnChainVerifier creates a new mock instance.
func NewMockEthOnChainVerifier(ctrl *gomock.Controller) *MockEthOnChainVerifier {
	mock := &MockEthOnChainVerifier{ctrl: ctrl}
	mock.recorder = &MockEthOnChainVerifierMockRecorder{mock}
	return mock
}

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

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

// CheckStakeDeposited indicates an expected call of CheckStakeDeposited.
func (mr *MockEthOnChainVerifierMockRecorder) CheckStakeDeposited(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckStakeDeposited", reflect.TypeOf((*MockEthOnChainVerifier)(nil).CheckStakeDeposited), arg0)
}

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

// CheckStakeRemoved indicates an expected call of CheckStakeRemoved.
func (mr *MockEthOnChainVerifierMockRecorder) CheckStakeRemoved(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckStakeRemoved", reflect.TypeOf((*MockEthOnChainVerifier)(nil).CheckStakeRemoved), arg0)
}

// MockWitness is a mock of Witness interface.
type MockWitness struct {
	ctrl     *gomock.Controller
	recorder *MockWitnessMockRecorder
}

// MockWitnessMockRecorder is the mock recorder for MockWitness.
type MockWitnessMockRecorder struct {
	mock *MockWitness
}

// NewMockWitness creates a new mock instance.
func NewMockWitness(ctrl *gomock.Controller) *MockWitness {
	mock := &MockWitness{ctrl: ctrl}
	mock.recorder = &MockWitnessMockRecorder{mock}
	return mock
}

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

// RestoreResource mocks base method.
func (m *MockWitness) RestoreResource(arg0 validators.Resource, arg1 func(interface{}, bool)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreResource", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestoreResource indicates an expected call of RestoreResource.
func (mr *MockWitnessMockRecorder) RestoreResource(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreResource", reflect.TypeOf((*MockWitness)(nil).RestoreResource), arg0, arg1)
}

// StartCheck mocks base method.
func (m *MockWitness) StartCheck(arg0 validators.Resource, arg1 func(interface{}, bool), arg2 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCheck", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartCheck indicates an expected call of StartCheck.
func (mr *MockWitnessMockRecorder) StartCheck(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCheck", reflect.TypeOf((*MockWitness)(nil).StartCheck), arg0, arg1, arg2)
}