mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/processor (interfaces: TimeService,EpochService,DelegationEngine,ExecutionEngine,GovernanceEngine,Stats,Assets,ValidatorTopology,Notary,EvtForwarder,Witness,Banking,NetworkParameters,OraclesEngine,OracleAdaptors,Limits,StakeVerifier,StakingAccounts,ERC20MultiSigTopology,Checkpoint)

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

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

	assets "code.vegaprotocol.io/vega/core/assets"
	common "code.vegaprotocol.io/vega/core/datasource/common"
	common0 "code.vegaprotocol.io/vega/core/execution/common"
	governance "code.vegaprotocol.io/vega/core/governance"
	types "code.vegaprotocol.io/vega/core/types"
	crypto "code.vegaprotocol.io/vega/libs/crypto"
	num "code.vegaprotocol.io/vega/libs/num"
	vega "code.vegaprotocol.io/vega/protos/vega"
	v1 "code.vegaprotocol.io/vega/protos/vega/commands/v1"
	gomock "github.com/golang/mock/gomock"
	types0 "github.com/tendermint/tendermint/abci/types"
)

// 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
}

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

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

// 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))
}

// NotifyOnTick mocks base method.
func (m *MockTimeService) NotifyOnTick(arg0 ...func(context.Context, time.Time)) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "NotifyOnTick", varargs...)
}

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

// SetTimeNow mocks base method.
func (m *MockTimeService) SetTimeNow(arg0 context.Context, arg1 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeNow", arg0, arg1)
}

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

// MockEpochService is a mock of EpochService interface.
type MockEpochService struct {
	ctrl     *gomock.Controller
	recorder *MockEpochServiceMockRecorder
}

// MockEpochServiceMockRecorder is the mock recorder for MockEpochService.
type MockEpochServiceMockRecorder struct {
	mock *MockEpochService
}

// NewMockEpochService creates a new mock instance.
func NewMockEpochService(ctrl *gomock.Controller) *MockEpochService {
	mock := &MockEpochService{ctrl: ctrl}
	mock.recorder = &MockEpochServiceMockRecorder{mock}
	return mock
}

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

// NotifyOnEpoch mocks base method.
func (m *MockEpochService) NotifyOnEpoch(arg0, arg1 func(context.Context, types.Epoch)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyOnEpoch", arg0, arg1)
}

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

// OnBlockEnd mocks base method.
func (m *MockEpochService) OnBlockEnd(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnBlockEnd", arg0)
}

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

// MockDelegationEngine is a mock of DelegationEngine interface.
type MockDelegationEngine struct {
	ctrl     *gomock.Controller
	recorder *MockDelegationEngineMockRecorder
}

// MockDelegationEngineMockRecorder is the mock recorder for MockDelegationEngine.
type MockDelegationEngineMockRecorder struct {
	mock *MockDelegationEngine
}

// NewMockDelegationEngine creates a new mock instance.
func NewMockDelegationEngine(ctrl *gomock.Controller) *MockDelegationEngine {
	mock := &MockDelegationEngine{ctrl: ctrl}
	mock.recorder = &MockDelegationEngineMockRecorder{mock}
	return mock
}

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

// Delegate mocks base method.
func (m *MockDelegationEngine) Delegate(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delegate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ProcessEpochDelegations mocks base method.
func (m *MockDelegationEngine) ProcessEpochDelegations(arg0 context.Context, arg1 types.Epoch) []*types.ValidatorData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEpochDelegations", arg0, arg1)
	ret0, _ := ret[0].([]*types.ValidatorData)
	return ret0
}

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

// UndelegateAtEndOfEpoch mocks base method.
func (m *MockDelegationEngine) UndelegateAtEndOfEpoch(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UndelegateAtEndOfEpoch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UndelegateNow mocks base method.
func (m *MockDelegationEngine) UndelegateNow(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UndelegateNow", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockExecutionEngine is a mock of ExecutionEngine interface.
type MockExecutionEngine struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionEngineMockRecorder
}

// MockExecutionEngineMockRecorder is the mock recorder for MockExecutionEngine.
type MockExecutionEngineMockRecorder struct {
	mock *MockExecutionEngine
}

// NewMockExecutionEngine creates a new mock instance.
func NewMockExecutionEngine(ctrl *gomock.Controller) *MockExecutionEngine {
	mock := &MockExecutionEngine{ctrl: ctrl}
	mock.recorder = &MockExecutionEngineMockRecorder{mock}
	return mock
}

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

// AmendLiquidityProvision mocks base method.
func (m *MockExecutionEngine) AmendLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionAmendment, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendLiquidityProvision", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// AmendOrder mocks base method.
func (m *MockExecutionEngine) AmendOrder(arg0 context.Context, arg1 *types.OrderAmendment, arg2 string, arg3 common0.IDGenerator) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendOrder", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BeginBlock mocks base method.
func (m *MockExecutionEngine) BeginBlock(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0)
}

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

// BlockEnd mocks base method.
func (m *MockExecutionEngine) BlockEnd(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BlockEnd", arg0)
}

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

// CancelLiquidityProvision mocks base method.
func (m *MockExecutionEngine) CancelLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionCancellation, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelLiquidityProvision", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CancelOrder mocks base method.
func (m *MockExecutionEngine) CancelOrder(arg0 context.Context, arg1 *types.OrderCancellation, arg2 string, arg3 common0.IDGenerator) ([]*types.OrderCancellationConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOrder", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.OrderCancellationConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelStopOrders mocks base method.
func (m *MockExecutionEngine) CancelStopOrders(arg0 context.Context, arg1 *types.StopOrdersCancellation, arg2 string, arg3 common0.IDGenerator) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelStopOrders", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

// SubmitLiquidityProvision mocks base method.
func (m *MockExecutionEngine) SubmitLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionSubmission, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitLiquidityProvision", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SubmitMarket mocks base method.
func (m *MockExecutionEngine) SubmitMarket(arg0 context.Context, arg1 *types.Market, arg2 string, arg3 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitMarket", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SubmitOrder mocks base method.
func (m *MockExecutionEngine) SubmitOrder(arg0 context.Context, arg1 *types.OrderSubmission, arg2 string, arg3 common0.IDGenerator, arg4 string) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitOrder", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitOrder indicates an expected call of SubmitOrder.
func (mr *MockExecutionEngineMockRecorder) SubmitOrder(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitOrder", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitOrder), arg0, arg1, arg2, arg3, arg4)
}

// SubmitSpotMarket mocks base method.
func (m *MockExecutionEngine) SubmitSpotMarket(arg0 context.Context, arg1 *types.Market, arg2 string, arg3 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitSpotMarket", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SubmitStopOrders mocks base method.
func (m *MockExecutionEngine) SubmitStopOrders(arg0 context.Context, arg1 *types.StopOrdersSubmission, arg2 string, arg3 common0.IDGenerator, arg4, arg5 *string) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitStopOrders", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitStopOrders indicates an expected call of SubmitStopOrders.
func (mr *MockExecutionEngineMockRecorder) SubmitStopOrders(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitStopOrders", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitStopOrders), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

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

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

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

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

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

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

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

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

// MockGovernanceEngine is a mock of GovernanceEngine interface.
type MockGovernanceEngine struct {
	ctrl     *gomock.Controller
	recorder *MockGovernanceEngineMockRecorder
}

// MockGovernanceEngineMockRecorder is the mock recorder for MockGovernanceEngine.
type MockGovernanceEngineMockRecorder struct {
	mock *MockGovernanceEngine
}

// NewMockGovernanceEngine creates a new mock instance.
func NewMockGovernanceEngine(ctrl *gomock.Controller) *MockGovernanceEngine {
	mock := &MockGovernanceEngine{ctrl: ctrl}
	mock.recorder = &MockGovernanceEngineMockRecorder{mock}
	return mock
}

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

// AddVote mocks base method.
func (m *MockGovernanceEngine) AddVote(arg0 context.Context, arg1 types.VoteSubmission, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddVote", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// FinaliseEnactment mocks base method.
func (m *MockGovernanceEngine) FinaliseEnactment(arg0 context.Context, arg1 *types.Proposal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FinaliseEnactment", arg0, arg1)
}

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

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

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

// OnTick mocks base method.
func (m *MockGovernanceEngine) OnTick(arg0 context.Context, arg1 time.Time) ([]*governance.ToEnact, []*governance.VoteClosed) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnTick", arg0, arg1)
	ret0, _ := ret[0].([]*governance.ToEnact)
	ret1, _ := ret[1].([]*governance.VoteClosed)
	return ret0, ret1
}

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

// RejectProposal mocks base method.
func (m *MockGovernanceEngine) RejectProposal(arg0 context.Context, arg1 *types.Proposal, arg2 vega.ProposalError, arg3 error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SubmitProposal mocks base method.
func (m *MockGovernanceEngine) SubmitProposal(arg0 context.Context, arg1 types.ProposalSubmission, arg2, arg3 string) (*governance.ToSubmit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*governance.ToSubmit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockStats is a mock of Stats interface.
type MockStats struct {
	ctrl     *gomock.Controller
	recorder *MockStatsMockRecorder
}

// MockStatsMockRecorder is the mock recorder for MockStats.
type MockStatsMockRecorder struct {
	mock *MockStats
}

// NewMockStats creates a new mock instance.
func NewMockStats(ctrl *gomock.Controller) *MockStats {
	mock := &MockStats{ctrl: ctrl}
	mock.recorder = &MockStatsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetHash mocks base method.
func (m *MockStats) SetHash(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHash", arg0)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockAssets is a mock of Assets interface.
type MockAssets struct {
	ctrl     *gomock.Controller
	recorder *MockAssetsMockRecorder
}

// MockAssetsMockRecorder is the mock recorder for MockAssets.
type MockAssetsMockRecorder struct {
	mock *MockAssets
}

// NewMockAssets creates a new mock instance.
func NewMockAssets(ctrl *gomock.Controller) *MockAssets {
	mock := &MockAssets{ctrl: ctrl}
	mock.recorder = &MockAssetsMockRecorder{mock}
	return mock
}

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

// EnactPendingAsset mocks base method.
func (m *MockAssets) EnactPendingAsset(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnactPendingAsset", arg0)
}

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

// Get mocks base method.
func (m *MockAssets) Get(arg0 string) (*assets.Asset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(*assets.Asset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewAsset mocks base method.
func (m *MockAssets) NewAsset(arg0 context.Context, arg1 string, arg2 *types.AssetDetails) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAsset", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockValidatorTopology is a mock of ValidatorTopology interface.
type MockValidatorTopology struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorTopologyMockRecorder
}

// MockValidatorTopologyMockRecorder is the mock recorder for MockValidatorTopology.
type MockValidatorTopologyMockRecorder struct {
	mock *MockValidatorTopology
}

// NewMockValidatorTopology creates a new mock instance.
func NewMockValidatorTopology(ctrl *gomock.Controller) *MockValidatorTopology {
	mock := &MockValidatorTopology{ctrl: ctrl}
	mock.recorder = &MockValidatorTopologyMockRecorder{mock}
	return mock
}

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

// AddForwarder mocks base method.
func (m *MockValidatorTopology) AddForwarder(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddForwarder", arg0)
}

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

// AddKeyRotate mocks base method.
func (m *MockValidatorTopology) AddKeyRotate(arg0 context.Context, arg1 string, arg2 uint64, arg3 *v1.KeyRotateSubmission) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddKeyRotate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// BeginBlock mocks base method.
func (m *MockValidatorTopology) BeginBlock(arg0 context.Context, arg1 types0.RequestBeginBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0, arg1)
}

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

// GetValidatorPowerUpdates mocks base method.
func (m *MockValidatorTopology) GetValidatorPowerUpdates() []types0.ValidatorUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValidatorPowerUpdates")
	ret0, _ := ret[0].([]types0.ValidatorUpdate)
	return ret0
}

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

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

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

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

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

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

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

// IssueSignatures mocks base method.
func (m *MockValidatorTopology) IssueSignatures(arg0 context.Context, arg1, arg2 string, arg3 v1.NodeSignatureKind) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueSignatures", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// ProcessEthereumKeyRotation mocks base method.
func (m *MockValidatorTopology) ProcessEthereumKeyRotation(arg0 context.Context, arg1 string, arg2 *v1.EthereumKeyRotateSubmission, arg3 func([]byte, []byte, string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEthereumKeyRotation", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ProcessValidatorHeartbeat mocks base method.
func (m *MockValidatorTopology) ProcessValidatorHeartbeat(arg0 context.Context, arg1 *v1.ValidatorHeartbeat, arg2 func([]byte, []byte, []byte) error, arg3 func([]byte, []byte, string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessValidatorHeartbeat", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockNotary is a mock of Notary interface.
type MockNotary struct {
	ctrl     *gomock.Controller
	recorder *MockNotaryMockRecorder
}

// MockNotaryMockRecorder is the mock recorder for MockNotary.
type MockNotaryMockRecorder struct {
	mock *MockNotary
}

// NewMockNotary creates a new mock instance.
func NewMockNotary(ctrl *gomock.Controller) *MockNotary {
	mock := &MockNotary{ctrl: ctrl}
	mock.recorder = &MockNotaryMockRecorder{mock}
	return mock
}

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

// IsSigned mocks base method.
func (m *MockNotary) IsSigned(arg0 context.Context, arg1 string, arg2 v1.NodeSignatureKind) ([]v1.NodeSignature, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSigned", arg0, arg1, arg2)
	ret0, _ := ret[0].([]v1.NodeSignature)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// RegisterSignature mocks base method.
func (m *MockNotary) RegisterSignature(arg0 context.Context, arg1 string, arg2 v1.NodeSignature) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterSignature", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StartAggregate mocks base method.
func (m *MockNotary) StartAggregate(arg0 string, arg1 v1.NodeSignatureKind, arg2 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartAggregate", arg0, arg1, arg2)
}

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

// 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
}

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

// Ack indicates an expected call of Ack.
func (mr *MockEvtForwarderMockRecorder) Ack(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ack", reflect.TypeOf((*MockEvtForwarder)(nil).Ack), 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
}

// AddNodeCheck mocks base method.
func (m *MockWitness) AddNodeCheck(arg0 context.Context, arg1 *v1.NodeVote, arg2 crypto.PublicKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNodeCheck", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockBanking is a mock of Banking interface.
type MockBanking struct {
	ctrl     *gomock.Controller
	recorder *MockBankingMockRecorder
}

// MockBankingMockRecorder is the mock recorder for MockBanking.
type MockBankingMockRecorder struct {
	mock *MockBanking
}

// NewMockBanking creates a new mock instance.
func NewMockBanking(ctrl *gomock.Controller) *MockBanking {
	mock := &MockBanking{ctrl: ctrl}
	mock.recorder = &MockBankingMockRecorder{mock}
	return mock
}

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

// BridgeResumed mocks base method.
func (m *MockBanking) BridgeResumed(arg0 context.Context, arg1 bool, arg2 string, arg3, arg4 uint64, arg5 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BridgeResumed", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// BridgeResumed indicates an expected call of BridgeResumed.
func (mr *MockBankingMockRecorder) BridgeResumed(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BridgeResumed", reflect.TypeOf((*MockBanking)(nil).BridgeResumed), arg0, arg1, arg2, arg3, arg4, arg5)
}

// BridgeStopped mocks base method.
func (m *MockBanking) BridgeStopped(arg0 context.Context, arg1 bool, arg2 string, arg3, arg4 uint64, arg5 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BridgeStopped", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// BridgeStopped indicates an expected call of BridgeStopped.
func (mr *MockBankingMockRecorder) BridgeStopped(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BridgeStopped", reflect.TypeOf((*MockBanking)(nil).BridgeStopped), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

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

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

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

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

// DepositBuiltinAsset mocks base method.
func (m *MockBanking) DepositBuiltinAsset(arg0 context.Context, arg1 *types.BuiltinAssetDeposit, arg2 string, arg3 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DepositBuiltinAsset", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DepositERC20 mocks base method.
func (m *MockBanking) DepositERC20(arg0 context.Context, arg1 *types.ERC20Deposit, arg2 string, arg3, arg4 uint64, arg5 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DepositERC20", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// DepositERC20 indicates an expected call of DepositERC20.
func (mr *MockBankingMockRecorder) DepositERC20(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepositERC20", reflect.TypeOf((*MockBanking)(nil).DepositERC20), arg0, arg1, arg2, arg3, arg4, arg5)
}

// ERC20WithdrawalEvent mocks base method.
func (m *MockBanking) ERC20WithdrawalEvent(arg0 context.Context, arg1 *types.ERC20Withdrawal, arg2, arg3 uint64, arg4 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ERC20WithdrawalEvent", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// ERC20WithdrawalEvent indicates an expected call of ERC20WithdrawalEvent.
func (mr *MockBankingMockRecorder) ERC20WithdrawalEvent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ERC20WithdrawalEvent", reflect.TypeOf((*MockBanking)(nil).ERC20WithdrawalEvent), arg0, arg1, arg2, arg3, arg4)
}

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

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

// EnableERC20 mocks base method.
func (m *MockBanking) EnableERC20(arg0 context.Context, arg1 *types.ERC20AssetList, arg2 string, arg3, arg4 uint64, arg5 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableERC20", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnableERC20 indicates an expected call of EnableERC20.
func (mr *MockBankingMockRecorder) EnableERC20(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableERC20", reflect.TypeOf((*MockBanking)(nil).EnableERC20), arg0, arg1, arg2, arg3, arg4, arg5)
}

// NewGovernanceTransfer mocks base method.
func (m *MockBanking) NewGovernanceTransfer(arg0 context.Context, arg1, arg2 string, arg3 *types.NewTransferConfiguration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGovernanceTransfer", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// UpdateERC20 mocks base method.
func (m *MockBanking) UpdateERC20(arg0 context.Context, arg1 *types.ERC20AssetLimitsUpdated, arg2 string, arg3, arg4 uint64, arg5 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateERC20", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateERC20 indicates an expected call of UpdateERC20.
func (mr *MockBankingMockRecorder) UpdateERC20(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateERC20", reflect.TypeOf((*MockBanking)(nil).UpdateERC20), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

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

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

// WithdrawBuiltinAsset mocks base method.
func (m *MockBanking) WithdrawBuiltinAsset(arg0 context.Context, arg1, arg2, arg3 string, arg4 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawBuiltinAsset", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithdrawBuiltinAsset indicates an expected call of WithdrawBuiltinAsset.
func (mr *MockBankingMockRecorder) WithdrawBuiltinAsset(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawBuiltinAsset", reflect.TypeOf((*MockBanking)(nil).WithdrawBuiltinAsset), arg0, arg1, arg2, arg3, arg4)
}

// WithdrawERC20 mocks base method.
func (m *MockBanking) WithdrawERC20(arg0 context.Context, arg1, arg2, arg3 string, arg4 *num.Uint, arg5 *types.Erc20WithdrawExt) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawERC20", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithdrawERC20 indicates an expected call of WithdrawERC20.
func (mr *MockBankingMockRecorder) WithdrawERC20(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawERC20", reflect.TypeOf((*MockBanking)(nil).WithdrawERC20), arg0, arg1, arg2, arg3, arg4, arg5)
}

// MockNetworkParameters is a mock of NetworkParameters interface.
type MockNetworkParameters struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkParametersMockRecorder
}

// MockNetworkParametersMockRecorder is the mock recorder for MockNetworkParameters.
type MockNetworkParametersMockRecorder struct {
	mock *MockNetworkParameters
}

// NewMockNetworkParameters creates a new mock instance.
func NewMockNetworkParameters(ctrl *gomock.Controller) *MockNetworkParameters {
	mock := &MockNetworkParameters{ctrl: ctrl}
	mock.recorder = &MockNetworkParametersMockRecorder{mock}
	return mock
}

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

// DispatchChanges mocks base method.
func (m *MockNetworkParameters) DispatchChanges(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DispatchChanges", arg0)
}

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

// GetInt mocks base method.
func (m *MockNetworkParameters) GetInt(arg0 string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInt", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// MockOraclesEngine is a mock of OraclesEngine interface.
type MockOraclesEngine struct {
	ctrl     *gomock.Controller
	recorder *MockOraclesEngineMockRecorder
}

// MockOraclesEngineMockRecorder is the mock recorder for MockOraclesEngine.
type MockOraclesEngineMockRecorder struct {
	mock *MockOraclesEngine
}

// NewMockOraclesEngine creates a new mock instance.
func NewMockOraclesEngine(ctrl *gomock.Controller) *MockOraclesEngine {
	mock := &MockOraclesEngine{ctrl: ctrl}
	mock.recorder = &MockOraclesEngineMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockOracleAdaptors is a mock of OracleAdaptors interface.
type MockOracleAdaptors struct {
	ctrl     *gomock.Controller
	recorder *MockOracleAdaptorsMockRecorder
}

// MockOracleAdaptorsMockRecorder is the mock recorder for MockOracleAdaptors.
type MockOracleAdaptorsMockRecorder struct {
	mock *MockOracleAdaptors
}

// NewMockOracleAdaptors creates a new mock instance.
func NewMockOracleAdaptors(ctrl *gomock.Controller) *MockOracleAdaptors {
	mock := &MockOracleAdaptors{ctrl: ctrl}
	mock.recorder = &MockOracleAdaptorsMockRecorder{mock}
	return mock
}

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

// Normalise mocks base method.
func (m *MockOracleAdaptors) Normalise(arg0 crypto.PublicKey, arg1 v1.OracleDataSubmission) (*common.Data, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Normalise", arg0, arg1)
	ret0, _ := ret[0].(*common.Data)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLimits is a mock of Limits interface.
type MockLimits struct {
	ctrl     *gomock.Controller
	recorder *MockLimitsMockRecorder
}

// MockLimitsMockRecorder is the mock recorder for MockLimits.
type MockLimitsMockRecorder struct {
	mock *MockLimits
}

// NewMockLimits creates a new mock instance.
func NewMockLimits(ctrl *gomock.Controller) *MockLimits {
	mock := &MockLimits{ctrl: ctrl}
	mock.recorder = &MockLimitsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockStakeVerifier is a mock of StakeVerifier interface.
type MockStakeVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockStakeVerifierMockRecorder
}

// MockStakeVerifierMockRecorder is the mock recorder for MockStakeVerifier.
type MockStakeVerifierMockRecorder struct {
	mock *MockStakeVerifier
}

// NewMockStakeVerifier creates a new mock instance.
func NewMockStakeVerifier(ctrl *gomock.Controller) *MockStakeVerifier {
	mock := &MockStakeVerifier{ctrl: ctrl}
	mock.recorder = &MockStakeVerifierMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockStakingAccounts is a mock of StakingAccounts interface.
type MockStakingAccounts struct {
	ctrl     *gomock.Controller
	recorder *MockStakingAccountsMockRecorder
}

// MockStakingAccountsMockRecorder is the mock recorder for MockStakingAccounts.
type MockStakingAccountsMockRecorder struct {
	mock *MockStakingAccounts
}

// NewMockStakingAccounts creates a new mock instance.
func NewMockStakingAccounts(ctrl *gomock.Controller) *MockStakingAccounts {
	mock := &MockStakingAccounts{ctrl: ctrl}
	mock.recorder = &MockStakingAccountsMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockERC20MultiSigTopology is a mock of ERC20MultiSigTopology interface.
type MockERC20MultiSigTopology struct {
	ctrl     *gomock.Controller
	recorder *MockERC20MultiSigTopologyMockRecorder
}

// MockERC20MultiSigTopologyMockRecorder is the mock recorder for MockERC20MultiSigTopology.
type MockERC20MultiSigTopologyMockRecorder struct {
	mock *MockERC20MultiSigTopology
}

// NewMockERC20MultiSigTopology creates a new mock instance.
func NewMockERC20MultiSigTopology(ctrl *gomock.Controller) *MockERC20MultiSigTopology {
	mock := &MockERC20MultiSigTopology{ctrl: ctrl}
	mock.recorder = &MockERC20MultiSigTopologyMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockCheckpoint is a mock of Checkpoint interface.
type MockCheckpoint struct {
	ctrl     *gomock.Controller
	recorder *MockCheckpointMockRecorder
}

// MockCheckpointMockRecorder is the mock recorder for MockCheckpoint.
type MockCheckpointMockRecorder struct {
	mock *MockCheckpoint
}

// NewMockCheckpoint creates a new mock instance.
func NewMockCheckpoint(ctrl *gomock.Controller) *MockCheckpoint {
	mock := &MockCheckpoint{ctrl: ctrl}
	mock.recorder = &MockCheckpointMockRecorder{mock}
	return mock
}

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

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

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

// Checkpoint mocks base method.
func (m *MockCheckpoint) Checkpoint(arg0 context.Context, arg1 time.Time) (*types.CheckpointState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Checkpoint", arg0, arg1)
	ret0, _ := ret[0].(*types.CheckpointState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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